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 
17 #include <functional>
18 #include <string>
19 
20 #include "common.h"
21 #include "rdb_errno.h"
22 #include "rdb_helper.h"
23 #include "rdb_open_callback.h"
24 #include "rdb_sql_statistic.h"
25 #include "rdb_store_manager.h"
26 #include "rdb_types.h"
27 
28 using namespace testing::ext;
29 using namespace OHOS::NativeRdb;
30 using namespace OHOS::DistributedRdb;
31 using CheckOnChangeFunc = std::function<void(RdbStoreObserver::ChangeInfo &changeInfo)>;
32 using SqlStatisticsFunc = std::function<void(SqlObserver::SqlExecutionInfo &info)>;
33 class SubObserver : public RdbStoreObserver {
34 public:
~SubObserver()35     virtual ~SubObserver()
36     {
37     }
38     void OnChange(const std::vector<std::string> &devices) override;
39     void OnChange(
40         const Origin &origin, const PrimaryFields &fields, RdbStoreObserver::ChangeInfo &&changeInfo) override;
41     void OnChange() override;
42     void RegisterCallback(const CheckOnChangeFunc &callback);
43     uint32_t count = 0;
44 
45 private:
46     CheckOnChangeFunc checkOnChangeFunc_;
47 };
48 
49 class StatisticsObserver : public SqlObserver {
50 public:
~StatisticsObserver()51     virtual ~StatisticsObserver()
52     {
53     }
54     void OnStatistic(const SqlExecutionInfo &info);
55     void Callback(const SqlStatisticsFunc &callback);
56 
57 private:
58     SqlStatisticsFunc sqlStatisticsFunc_;
59 };
60 
61 class RdbStoreSubTest : public testing::Test {
62 public:
63     static void SetUpTestCase(void);
64     static void TearDownTestCase(void);
65     void SetUp();
66     void TearDown();
67 
68     static const std::string MAIN_DATABASE_NAME;
69     static std::shared_ptr<RdbStore> CreateRDB(int version);
70     static void RegisterCheckInsertCallback(const std::vector<std::shared_ptr<SubObserver>> &SubObservers);
71     static void RegisterCheckUpdateCallback(const std::vector<std::shared_ptr<SubObserver>> &SubObservers);
72     static std::shared_ptr<RdbStore> store;
73     static std::shared_ptr<SubObserver> observer_;
74     static std::shared_ptr<StatisticsObserver> sqlObserver_;
75 };
76 
77 class TestDetailProgressObserver : public DetailProgressObserver {
78 public:
~TestDetailProgressObserver()79     virtual ~TestDetailProgressObserver()
80     {
81     }
ProgressNotification(const Details & details)82     void ProgressNotification(const Details &details) override{};
83 };
84 
85 const std::string RdbStoreSubTest::MAIN_DATABASE_NAME = RDB_TEST_PATH + "subscribe.db";
86 std::shared_ptr<RdbStore> RdbStoreSubTest::store = nullptr;
87 std::shared_ptr<SubObserver> RdbStoreSubTest::observer_ = nullptr;
88 std::shared_ptr<StatisticsObserver> RdbStoreSubTest::sqlObserver_ = nullptr;
89 
SetUpTestCase(void)90 void RdbStoreSubTest::SetUpTestCase(void)
91 {
92     RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME);
93     store = CreateRDB(1);
94     if (observer_ == nullptr) {
95         observer_ = std::make_shared<SubObserver>();
96     }
97     if (sqlObserver_ == nullptr) {
98         sqlObserver_ = std::make_shared<StatisticsObserver>();
99     }
100 }
101 
TearDownTestCase(void)102 void RdbStoreSubTest::TearDownTestCase(void)
103 {
104     store = nullptr;
105     RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME);
106 }
107 
SetUp()108 void RdbStoreSubTest::SetUp()
109 {
110 }
111 
TearDown()112 void RdbStoreSubTest::TearDown()
113 {
114 }
115 
116 class Callback : public RdbOpenCallback {
117 public:
118     int OnCreate(RdbStore &store) override;
119     int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
120 };
121 
OnCreate(RdbStore & store)122 int Callback::OnCreate(RdbStore &store)
123 {
124     return E_OK;
125 }
126 
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)127 int Callback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
128 {
129     return E_OK;
130 }
131 
OnChange(const std::vector<std::string> & devices)132 void SubObserver::OnChange(const std::vector<std::string> &devices)
133 {
134 }
135 
OnChange(const Origin & origin,const PrimaryFields & fields,RdbStoreObserver::ChangeInfo && changeInfo)136 void SubObserver::OnChange(const Origin &origin, const PrimaryFields &fields, RdbStoreObserver::ChangeInfo &&changeInfo)
137 {
138     count++;
139     if (checkOnChangeFunc_) {
140         checkOnChangeFunc_(changeInfo);
141     }
142 }
143 
OnChange()144 void SubObserver::OnChange()
145 {
146     const std::string CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test "
147                                           "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
148                                           "name TEXT NOT NULL, age INTEGER, salary "
149                                           "REAL, blobType BLOB)";
150     RdbStoreSubTest::store->ExecuteSql(CREATE_TABLE_TEST);
151     ValuesBucket values;
152     int64_t id;
153     values.PutInt("id", 1);
154     values.PutString("name", std::string("zhangsan"));
155     values.PutInt("age", 18);
156     values.PutDouble("salary", 100.5);
157     values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
158     int ret = RdbStoreSubTest::store->Insert(id, "test", values);
159     EXPECT_EQ(ret, E_OK);
160     EXPECT_EQ(1, id);
161 }
162 
RegisterCallback(const CheckOnChangeFunc & callback)163 void SubObserver::RegisterCallback(const CheckOnChangeFunc &callback)
164 {
165     checkOnChangeFunc_ = callback;
166 }
167 
OnStatistic(const StatisticsObserver::SqlExecutionInfo & info)168 void StatisticsObserver::OnStatistic(const StatisticsObserver::SqlExecutionInfo &info)
169 {
170 }
171 
Callback(const SqlStatisticsFunc & callback)172 void StatisticsObserver::Callback(const SqlStatisticsFunc &callback)
173 {
174     sqlStatisticsFunc_ = callback;
175 }
176 
CreateRDB(int version)177 std::shared_ptr<RdbStore> RdbStoreSubTest::CreateRDB(int version)
178 {
179     RdbStoreConfig config(RdbStoreSubTest::MAIN_DATABASE_NAME);
180     config.SetBundleName("subscribe_test");
181     config.SetArea(0);
182     config.SetCreateNecessary(true);
183     config.SetDistributedType(RDB_DEVICE_COLLABORATION);
184     config.SetSecurityLevel(OHOS::NativeRdb::SecurityLevel::S1);
185     Callback helper;
186     int errCode = E_OK;
187     std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, version, helper, errCode);
188     EXPECT_NE(store, nullptr);
189     return store;
190 }
191 
RegisterCheckInsertCallback(const std::vector<std::shared_ptr<SubObserver>> & SubObservers)192 void RdbStoreSubTest::RegisterCheckInsertCallback(const std::vector<std::shared_ptr<SubObserver>> &SubObservers)
193 {
194     for (const auto &observer : SubObservers) {
195         observer->RegisterCallback([](RdbStoreObserver::ChangeInfo &changeInfo) {
196             ASSERT_EQ(changeInfo.size(), 1u);
197             EXPECT_TRUE(changeInfo["local_test"][1].empty());
198             EXPECT_TRUE(changeInfo["local_test"][2].empty()); // 2 is delete subscript
199             EXPECT_EQ(std::get<int64_t>(changeInfo["local_test"][0][0]), 1);
200         });
201     }
202 }
203 
RegisterCheckUpdateCallback(const std::vector<std::shared_ptr<SubObserver>> & SubObservers)204 void RdbStoreSubTest::RegisterCheckUpdateCallback(const std::vector<std::shared_ptr<SubObserver>> &SubObservers)
205 {
206     for (const auto &observer : SubObservers) {
207         observer->RegisterCallback([](RdbStoreObserver::ChangeInfo &changeInfo) {
208             ASSERT_EQ(changeInfo.size(), 1u);
209             EXPECT_TRUE(changeInfo["local_test"][0].empty());
210             EXPECT_TRUE(changeInfo["local_test"][2].empty()); // 2 is delete subscript
211             EXPECT_EQ(std::get<int64_t>(changeInfo["local_test"][1][0]), 1);
212         });
213     }
214 }
215 
216 /**
217  * @tc.name: RdbStoreSubscribeRemote
218  * @tc.desc: RdbStoreSubscribe
219  * @tc.type: FUNC
220  * @tc.require:
221  * @tc.author:
222  */
223 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeRemote, TestSize.Level1)
224 {
225     EXPECT_NE(store, nullptr) << "store is null";
226     EXPECT_NE(observer_, nullptr) << "observer is null";
227     auto status = store->Subscribe({ SubscribeMode::REMOTE }, observer_.get());
228     EXPECT_EQ(status, E_OK);
229 }
230 
231 /**
232  * @tc.name: RdbStoreSubscribeCloud
233  * @tc.desc: RdbStoreSubscribe
234  * @tc.type: FUNC
235  * @tc.require:
236  * @tc.author:
237  */
238 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeCloud, TestSize.Level1)
239 {
240     EXPECT_NE(store, nullptr) << "store is null";
241     EXPECT_NE(observer_, nullptr) << "observer is null";
242     auto status = store->Subscribe({ SubscribeMode::CLOUD }, observer_.get());
243     EXPECT_EQ(status, E_OK);
244 }
245 
246 /**
247  * @tc.name: RdbStoreSubscribeCloudDetail
248  * @tc.desc: RdbStoreSubscribe
249  * @tc.type: FUNC
250  * @tc.require:
251  * @tc.author:
252  */
253 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeCloudDetail, TestSize.Level1)
254 {
255     EXPECT_NE(store, nullptr) << "store is null";
256     EXPECT_NE(observer_, nullptr) << "observer is null";
257     auto status = store->Subscribe({ SubscribeMode::CLOUD_DETAIL }, observer_.get());
258     EXPECT_EQ(status, E_OK);
259 }
260 
261 /**
262  * @tc.name: RdbStoreSubscribeLocal
263  * @tc.desc: RdbStoreSubscribe
264  * @tc.type: FUNC
265  * @tc.require:
266  * @tc.author:
267  */
268 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocal, TestSize.Level1)
269 {
270     EXPECT_NE(store, nullptr) << "store is null";
271     EXPECT_NE(observer_, nullptr) << "observer is null";
272     auto status = store->Subscribe({ SubscribeMode::LOCAL, "observer" }, observer_.get());
273     EXPECT_EQ(status, E_OK);
274 
275     status = store->Notify("observer");
276     EXPECT_EQ(status, E_OK);
277 
278     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
279     int count;
280     resultSet->GetRowCount(count);
281     EXPECT_EQ(1, count);
282 }
283 
284 /**
285  * @tc.name: RdbStoreSubscribeLocalDetail001
286  * @tc.desc: test local observer onchange when insert data
287  * @tc.type: FUNC
288  * @tc.require:
289  * @tc.author:
290  */
291 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail001, TestSize.Level1)
292 {
293     EXPECT_NE(store, nullptr) << "store is null";
294     EXPECT_NE(observer_, nullptr) << "observer is null";
295     constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test "
296                                             "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
297                                             "name TEXT NOT NULL, age INTEGER)";
298     store->ExecuteSql(createTableTest);
299     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
300     EXPECT_EQ(status, E_OK);
301     EXPECT_EQ(status, E_OK);
302     auto observer2 = std::make_shared<SubObserver>();
303     status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
304 
305     RegisterCheckInsertCallback({ observer_, observer2 });
306 
307     ValuesBucket values;
308     int64_t id;
309     values.PutInt("id", 1);
310     values.PutString("name", std::string("zhangsan"));
311     values.PutInt("age", 18); // 18 is random age
312     status = store->Insert(id, "local_test", values);
313     EXPECT_EQ(status, E_OK);
314     EXPECT_EQ(id, 1);
315 
__anonb9bbbf4f0302(RdbStoreObserver::ChangeInfo &) 316     observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
__anonb9bbbf4f0402(RdbStoreObserver::ChangeInfo &) 317     observer2->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
318     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
319     EXPECT_EQ(status, E_OK);
320     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
321     EXPECT_EQ(status, E_OK);
322 
323     ValuesBucket values2;
324     int id2;
325     values2.PutString("name", std::string("zhangsan_update1"));
326     values2.PutInt("age", 19); // 19 is random age
327     AbsRdbPredicates predicates("local_test");
328     predicates.EqualTo("id", 1);
329     status = store->Update(id2, values2, predicates);
330     EXPECT_EQ(status, E_OK);
331     EXPECT_EQ(id2, 1);
332     observer_->RegisterCallback(nullptr);
333     observer2->RegisterCallback(nullptr);
334 }
335 
336 /**
337  * @tc.name: RdbStoreSubscribeLocalDetail002
338  * @tc.desc: test local observer onchange when update data
339  * @tc.type: FUNC
340  * @tc.require:
341  * @tc.author:
342  */
343 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail002, TestSize.Level1)
344 {
345     EXPECT_NE(store, nullptr) << "store is null";
346     EXPECT_NE(observer_, nullptr) << "observer is null";
347     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
348     EXPECT_EQ(status, E_OK);
349     EXPECT_EQ(status, E_OK);
350     auto observer2 = std::make_shared<SubObserver>();
351     status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
352 
353     RegisterCheckUpdateCallback({ observer_, observer2 });
354 
355     int id;
356     ValuesBucket values;
357     values.PutString("name", std::string("zhangsan_update2"));
358     values.PutInt("age", 20); // 20 is random age
359     AbsRdbPredicates predicates("local_test");
360     predicates.EqualTo("id", 1);
361     status = store->Update(id, values, predicates);
362     EXPECT_EQ(status, E_OK);
363     EXPECT_EQ(id, 1);
364 
__anonb9bbbf4f0502(RdbStoreObserver::ChangeInfo &) 365     observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
366     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
367     EXPECT_EQ(status, E_OK);
368 
369     ValuesBucket values2;
370     int id2;
371     values2.PutString("name", std::string("zhangsan_update1"));
372     values2.PutInt("age", 19); // 19 is random age
373     AbsRdbPredicates predicates2("local_test");
374     predicates2.EqualTo("id", 1);
375     status = store->Update(id2, values2, predicates2);
376     EXPECT_EQ(status, E_OK);
377     EXPECT_EQ(id2, 1);
378     observer_->RegisterCallback(nullptr);
379     observer2->RegisterCallback(nullptr);
380     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
381     EXPECT_EQ(status, E_OK);
382 }
383 
384 /**
385  * @tc.name: RdbStoreSubscribeLocalDetail003
386  * @tc.desc: test local observer onchange when delete data
387  * @tc.type: FUNC
388  * @tc.require:
389  * @tc.author:
390  */
391 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail003, TestSize.Level1)
392 {
393     EXPECT_NE(store, nullptr) << "store is null";
394     EXPECT_NE(observer_, nullptr) << "observer is null";
395     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
396     EXPECT_EQ(status, E_OK);
397 
__anonb9bbbf4f0602(RdbStoreObserver::ChangeInfo &changeInfo) 398     observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &changeInfo) {
399         ASSERT_EQ(changeInfo.size(), 1u);
400         EXPECT_TRUE(changeInfo["local_test"][0].empty());
401         EXPECT_TRUE(changeInfo["local_test"][1].empty());
402         EXPECT_EQ(std::get<int64_t>(changeInfo["local_test"][2][0]), 1);
403     });
404 
405     observer_->count = 0;
406     int id;
407     status = store->Delete(id, "local_test", "id = ?", std::vector<std::string>{ "1" });
408     EXPECT_EQ(status, E_OK);
409     EXPECT_EQ(id, 1);
410     EXPECT_EQ(observer_->count, 1);
411 
412     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
413     EXPECT_EQ(status, E_OK);
414     observer_->RegisterCallback(nullptr);
415 }
416 
417 /**
418  * @tc.name: RdbStoreSubscribeLocalDetail004
419  * @tc.desc: test local observer onchange when batchinsert data
420  * @tc.type: FUNC
421  * @tc.require:
422  * @tc.author:
423  */
424 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail004, TestSize.Level1)
425 {
426     int num = 10;
427     EXPECT_NE(store, nullptr) << "store is null";
428     EXPECT_NE(observer_, nullptr) << "observer is null";
429     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
430     EXPECT_EQ(status, E_OK);
431 
__anonb9bbbf4f0702(RdbStoreObserver::ChangeInfo &changeInfo) 432     observer_->RegisterCallback([num](RdbStoreObserver::ChangeInfo &changeInfo) {
433         ASSERT_EQ(changeInfo.size(), 1u);
434         EXPECT_TRUE(changeInfo["local_test"][1].empty());
435         EXPECT_TRUE(changeInfo["local_test"][2].empty()); // 2 is delete subscript
436         for (int i = 0; i < num; i++) {
437             EXPECT_EQ(std::get<int64_t>(changeInfo["local_test"][0][i]), i);
438         }
439     });
440 
441     observer_->count = 0;
442     int64_t id;
443     std::vector<ValuesBucket> values;
444     for (int i = 0; i < num; i++) {
445         ValuesBucket value;
446         value.PutInt("id", i);
447         value.PutString("name", std::string("zhangsan"));
448         value.PutInt("age", 18); // 18 is random age
449         values.push_back(value);
450     }
451     status = store->BatchInsert(id, "local_test", values);
452     EXPECT_EQ(status, E_OK);
453     EXPECT_EQ(id, num);
454     EXPECT_EQ(observer_->count, 1);
455     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
456     EXPECT_EQ(status, E_OK);
457     observer_->RegisterCallback(nullptr);
458 }
459 
460 /**
461  * @tc.name: RdbStoreSubscribeLocalDetail005
462  * @tc.desc: test local observer onchange when create table after register observer
463  * @tc.type: FUNC
464  * @tc.require:
465  * @tc.author:
466  */
467 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail005, TestSize.Level1)
468 {
469     int num = 1;
470     EXPECT_NE(store, nullptr) << "store is null";
471     EXPECT_NE(observer_, nullptr) << "observer is null";
472     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
473     EXPECT_EQ(status, E_OK);
474     constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test1 "
475                                             "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
476                                             "name TEXT NOT NULL, age INTEGER)";
477     store->ExecuteSql(createTableTest);
478 
__anonb9bbbf4f0802(RdbStoreObserver::ChangeInfo &changeInfo) 479     observer_->RegisterCallback([num](RdbStoreObserver::ChangeInfo &changeInfo) {
480         ASSERT_EQ(changeInfo.size(), 1u);
481         EXPECT_TRUE(changeInfo["local_test1"][1].empty());
482         EXPECT_TRUE(changeInfo["local_test1"][2].empty()); // 2 is delete subscript
483         for (int i = 0; i < num; i++) {
484             EXPECT_EQ(std::get<int64_t>(changeInfo["local_test1"][0][i]), i);
485         }
486     });
487     observer_->count = 0;
488 
489     int64_t id;
490     std::vector<ValuesBucket> values;
491     for (int i = 0; i < num; i++) {
492         ValuesBucket value;
493         value.PutInt("id", i);
494         value.PutString("name", std::string("zhangsan"));
495         value.PutInt("age", 18); // 18 is random age
496         values.push_back(value);
497     }
498     status = store->BatchInsert(id, "local_test1", values);
499     EXPECT_EQ(status, E_OK);
500     EXPECT_EQ(id, num);
501     EXPECT_EQ(observer_->count, 1);
502     status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
503     EXPECT_EQ(status, E_OK);
504     observer_->RegisterCallback(nullptr);
505 }
506 
507 /**
508  * @tc.name: RdbStoreSubscribeLocalDetail006
509  * @tc.desc: test abnormal parametar subscribe
510  * @tc.type: FUNC
511  * @tc.require:
512  * @tc.author:
513  */
514 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail006, TestSize.Level1)
515 {
516     EXPECT_NE(store, nullptr) << "store is null";
517     EXPECT_NE(observer_, nullptr) << "observer is null";
518     auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, nullptr);
519     EXPECT_EQ(status, E_OK);
__anonb9bbbf4f0902(RdbStoreObserver::ChangeInfo &) 520     observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
521     ValuesBucket values;
522     int id;
523     values.PutString("name", std::string("zhangsan_update1"));
524     values.PutInt("age", 19); // 19 is random age
525     AbsRdbPredicates predicates("local_test");
526     predicates.EqualTo("id", 1);
527     status = store->Update(id, values, predicates);
528     EXPECT_EQ(status, E_OK);
529     EXPECT_EQ(id, 1); // 2 is random id
530     observer_->RegisterCallback(nullptr);
531 }
532 
533 /**
534  * @tc.name: RdbStoreSubscribeStatistics001
535  * @tc.desc: test statistics observer when insert data
536  * @tc.type: FUNC
537  * @tc.require:
538  * @tc.author:
539  */
540 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics001, TestSize.Level1)
541 {
542     EXPECT_NE(store, nullptr) << "store is null";
543     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
544     constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS statistics_test "
545                                             "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
546                                             "name TEXT NOT NULL, age INTEGER)";
547     store->ExecuteSql(createTableTest);
548     auto status = SqlStatistic::Subscribe(sqlObserver_);
549     EXPECT_EQ(status, E_OK);
550     auto observer2 = std::make_shared<StatisticsObserver>();
551     status = SqlStatistic::Subscribe(sqlObserver_);
552     ValuesBucket values;
553     int64_t id;
554     values.PutInt("id", 1);
555     values.PutString("name", std::string("zhangsan"));
556     values.PutInt("age", 18); // 18 is random age
557     status = store->Insert(id, "statistics_test", values);
558     EXPECT_EQ(status, E_OK);
559     EXPECT_EQ(id, 1);
__anonb9bbbf4f0a02(SqlObserver::SqlExecutionInfo &info) 560     sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
__anonb9bbbf4f0b02(SqlObserver::SqlExecutionInfo &info) 561     observer2->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
562     status = SqlStatistic::Unsubscribe(sqlObserver_);
563     EXPECT_EQ(status, E_OK);
564     status = SqlStatistic::Unsubscribe(observer2);
565     EXPECT_EQ(status, E_OK);
566 }
567 
568 /**
569  * @tc.name: RdbStoreSubscribeStatistics002
570  * @tc.desc: test statistics observer when update data
571  * @tc.type: FUNC
572  * @tc.require:
573  * @tc.author:
574  */
575 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics002, TestSize.Level1)
576 {
577     EXPECT_NE(store, nullptr) << "store is null";
578     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
579     auto status = SqlStatistic::Subscribe(sqlObserver_);
580     EXPECT_EQ(status, E_OK);
581     int id;
582     ValuesBucket values;
583     values.PutString("name", std::string("zhangsan_update2"));
584     values.PutInt("age", 20); // 20 is random age
585     AbsRdbPredicates predicates("statistics_test");
586     predicates.EqualTo("id", 1);
587     status = store->Update(id, values, predicates);
588     EXPECT_EQ(status, E_OK);
589     EXPECT_EQ(id, 1);
__anonb9bbbf4f0c02(SqlObserver::SqlExecutionInfo &info) 590     sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
591     status = SqlStatistic::Unsubscribe(sqlObserver_);
592     EXPECT_EQ(status, E_OK);
593 }
594 
595 /**
596  * @tc.name: RdbStoreSubscribeStatistics003
597  * @tc.desc: test statistics observer when delete data
598  * @tc.type: FUNC
599  * @tc.require:
600  * @tc.author:
601  */
602 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics003, TestSize.Level1)
603 {
604     EXPECT_NE(store, nullptr) << "store is null";
605     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
606     auto status = SqlStatistic::Subscribe(sqlObserver_);
607     EXPECT_EQ(status, E_OK);
__anonb9bbbf4f0d02(SqlObserver::SqlExecutionInfo &info) 608     sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
609     int id;
610     status = store->Delete(id, "statistics_test", "id = ?", std::vector<std::string>{ "1" });
611     EXPECT_EQ(status, E_OK);
612     EXPECT_EQ(id, 1);
613 
614     status = SqlStatistic::Unsubscribe(sqlObserver_);
615     EXPECT_EQ(status, E_OK);
616     sqlObserver_->Callback(nullptr);
617 }
618 
619 /**
620  * @tc.name: RdbStoreSubscribeStatistics001
621  * @tc.desc: test statistics observer when batchinsert data
622  * @tc.type: FUNC
623  * @tc.require:
624  * @tc.author:
625  */
626 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics004, TestSize.Level1)
627 {
628     int num = 10;
629     EXPECT_NE(store, nullptr) << "store is null";
630     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
631     auto status = SqlStatistic::Subscribe(sqlObserver_);
632     EXPECT_EQ(status, E_OK);
__anonb9bbbf4f0e02(SqlObserver::SqlExecutionInfo &info) 633     sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
634     int64_t id;
635     std::vector<ValuesBucket> values;
636     for (int i = 0; i < num; i++) {
637         ValuesBucket value;
638         value.PutInt("id", i);
639         value.PutString("name", std::string("zhangsan"));
640         value.PutInt("age", 18); // 18 is random age
641         values.push_back(value);
642     }
643     status = store->BatchInsert(id, "statistics_test", values);
644     EXPECT_EQ(status, E_OK);
645     EXPECT_EQ(id, num);
646     status = SqlStatistic::Unsubscribe(sqlObserver_);
647     EXPECT_EQ(status, E_OK);
648 }
649 
650 /**
651  * @tc.name: RdbStoreSubscribeStatistics001
652  * @tc.desc: test statistics observer when create table after register observer
653  * @tc.type: FUNC
654  * @tc.require:
655  * @tc.author:
656  */
657 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics005, TestSize.Level1)
658 {
659     EXPECT_NE(store, nullptr) << "store is null";
660     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
661     auto status = SqlStatistic::Subscribe(sqlObserver_);
662     EXPECT_EQ(status, E_OK);
663     constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS statistics_test1 "
664                                             "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
665                                             "name TEXT NOT NULL, age INTEGER)";
666     store->ExecuteSql(createTableTest);
667 
__anonb9bbbf4f0f02(SqlObserver::SqlExecutionInfo &info) 668     sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 3); });
669     ValuesBucket values;
670     int64_t id;
671     values.PutInt("id", 1);
672     values.PutString("name", std::string("zhangsan"));
673     values.PutInt("age", 18); // 18 is random age
674     status = store->Insert(id, "statistics_test1", values);
675     EXPECT_EQ(status, E_OK);
676     EXPECT_EQ(id, 1);
677     status = SqlStatistic::Unsubscribe(sqlObserver_);
678     EXPECT_EQ(status, E_OK);
679 }
680 
681 /**
682  * @tc.name: RdbStoreSubscribeStatistics006
683  * @tc.desc: test statistics observer when query data
684  * @tc.type: FUNC
685  * @tc.require:
686  * @tc.author:
687  */
688 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics006, TestSize.Level1)
689 {
690     EXPECT_NE(store, nullptr) << "store is null";
691     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
692     auto status = SqlStatistic::Subscribe(sqlObserver_);
693     EXPECT_EQ(status, E_OK);
__anonb9bbbf4f1002(SqlObserver::SqlExecutionInfo &info) 694     sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 2); });
695     std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM statistics_test");
696     EXPECT_NE(resultSet, nullptr);
697     status = SqlStatistic::Unsubscribe(sqlObserver_);
698     EXPECT_EQ(status, E_OK);
699 }
700 
701 /**
702  * @tc.name: RdbStoreSubscribeStatistics007
703  * @tc.desc: test statistics observer when query data
704  * @tc.type: FUNC
705  * @tc.require:
706  * @tc.author:
707  */
708 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics007, TestSize.Level1)
709 {
710     EXPECT_NE(store, nullptr) << "store is null";
711     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
712     auto status = SqlStatistic::Subscribe(sqlObserver_);
713     EXPECT_EQ(status, E_OK);
__anonb9bbbf4f1102(SqlObserver::SqlExecutionInfo &info) 714     sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 2); });
715     std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM statistics_test");
716     EXPECT_NE(resultSet, nullptr);
717     status = SqlStatistic::Unsubscribe(sqlObserver_);
718     EXPECT_EQ(status, E_OK);
719 }
720 
721 /**
722  * @tc.name: RdbStoreSubscribeStatistics008
723  * @tc.desc: test statistics observer when Execute pragma
724  * @tc.type: FUNC
725  * @tc.require:
726  * @tc.author:
727  */
728 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics008, TestSize.Level1)
729 {
730     EXPECT_NE(store, nullptr) << "store is null";
731     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
732     auto status = SqlStatistic::Subscribe(sqlObserver_);
733     EXPECT_EQ(status, E_OK);
__anonb9bbbf4f1202(SqlObserver::SqlExecutionInfo &info) 734     sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_[0], "PRAGMA quick_check"); });
735     auto [ret, object] = store->Execute("PRAGMA quick_check");
736     status = SqlStatistic::Unsubscribe(sqlObserver_);
737     EXPECT_EQ(status, E_OK);
738 }
739 
740 /**
741  * @tc.name: RdbStoreSubscribeStatistics009
742  * @tc.desc: test statistics observer when ExecuteSql
743  * @tc.type: FUNC
744  * @tc.require:
745  * @tc.author:
746  */
747 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics009, TestSize.Level1)
748 {
749     EXPECT_NE(store, nullptr) << "store is null";
750     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
751     std::string value = "with test as (select * from statistics_test) select * from test1";
752     auto status = SqlStatistic::Subscribe(sqlObserver_);
753     EXPECT_EQ(status, E_OK);
__anonb9bbbf4f1302(SqlObserver::SqlExecutionInfo &info) 754     sqlObserver_->Callback([value](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_[0], value); });
755     store->ExecuteSql(value);
756     status = SqlStatistic::Unsubscribe(sqlObserver_);
757     EXPECT_EQ(status, E_OK);
758 }
759 
760 /**
761  * @tc.name: RdbStoreSubscribeStatistics010
762  * @tc.desc: test abnormal parametar subscribe
763  * @tc.type: FUNC
764  * @tc.require:
765  * @tc.author:
766  */
767 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics010, TestSize.Level1)
768 {
769     EXPECT_NE(store, nullptr) << "store is null";
770     EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
771     auto status = SqlStatistic::Subscribe(nullptr);
772     EXPECT_EQ(status, E_OK);
773 }
774 
775 /**
776 * @tc.name: RdbStore_RegisterAutoSyncCallbackAndRdbStore_UnregisterAutoSyncCallback_001
777 * @tc.desc: Test RegisterAutoSyncCallback and UnregisterAutoSyncCallback
778 * @tc.type: FUNC
779 */
780 HWTEST_F(RdbStoreSubTest, RdbStore_RegisterAutoSyncCallbackAndRdbStore_UnregisterAutoSyncCallback_001, TestSize.Level1)
781 {
782     EXPECT_NE(store, nullptr) << "store is null";
783     auto obs = std::make_shared<TestDetailProgressObserver>();
784     auto status = store->RegisterAutoSyncCallback(obs);
785     EXPECT_EQ(status, E_OK);
786 
787     status = store->UnregisterAutoSyncCallback(obs);
788     EXPECT_EQ(status, E_OK);
789 }
790