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 "block_data.h"
21 #include "common.h"
22 #include "rdb_errno.h"
23 #include "rdb_helper.h"
24 #include "rdb_open_callback.h"
25 #include "rdb_sql_statistic.h"
26 #include "rdb_store_manager.h"
27 #include "rdb_types.h"
28
29 using namespace testing::ext;
30 using namespace OHOS::NativeRdb;
31 using namespace OHOS::DistributedRdb;
32 using CheckOnChangeFunc = std::function<void(RdbStoreObserver::ChangeInfo &changeInfo)>;
33 using SqlStatisticsFunc = std::function<void(SqlObserver::SqlExecutionInfo &info)>;
34 class SubObserver : public RdbStoreObserver {
35 public:
~SubObserver()36 virtual ~SubObserver()
37 {
38 }
39 void OnChange(const std::vector<std::string> &devices) override;
40 void OnChange(
41 const Origin &origin, const PrimaryFields &fields, RdbStoreObserver::ChangeInfo &&changeInfo) override;
42 void OnChange() override;
43 void RegisterCallback(const CheckOnChangeFunc &callback);
44 uint32_t count = 0;
45
46 private:
47 CheckOnChangeFunc checkOnChangeFunc_;
48 };
49 class LocalShareObserver : public RdbStoreObserver {
50 public:
LocalShareObserver(std::function<void ()> func)51 explicit LocalShareObserver(std::function<void()> func) : callback_(func)
52 {
53 }
OnChange(const std::vector<std::string> & devices)54 void OnChange(const std::vector<std::string> &devices){};
OnChange()55 void OnChange()
56 {
57 if (callback_ != nullptr) {
58 callback_();
59 }
60 };
61
62 private:
63 std::function<void()> callback_;
64 };
65
66 class StatisticsObserver : public SqlObserver {
67 public:
~StatisticsObserver()68 virtual ~StatisticsObserver()
69 {
70 }
71 void OnStatistic(const SqlExecutionInfo &info);
72 void Callback(const SqlStatisticsFunc &callback);
73
74 private:
75 SqlStatisticsFunc sqlStatisticsFunc_;
76 };
77
78 class RdbStoreSubTest : public testing::Test {
79 public:
80 static void SetUpTestCase(void);
81 static void TearDownTestCase(void);
82 void SetUp();
83 void TearDown();
84
85 static const std::string MAIN_DATABASE_NAME;
86 static std::shared_ptr<RdbStore> CreateRDB(int version);
87 static void RegisterCheckInsertCallback(const std::vector<std::shared_ptr<SubObserver>> &SubObservers);
88 static void RegisterCheckUpdateCallback(const std::vector<std::shared_ptr<SubObserver>> &SubObservers);
89 static std::shared_ptr<RdbStore> store;
90 static std::shared_ptr<SubObserver> observer_;
91 static std::shared_ptr<StatisticsObserver> sqlObserver_;
92 };
93
94 class TestDetailProgressObserver : public DetailProgressObserver {
95 public:
~TestDetailProgressObserver()96 virtual ~TestDetailProgressObserver()
97 {
98 }
ProgressNotification(const Details & details)99 void ProgressNotification(const Details &details) override {};
100 };
101
102 const std::string RdbStoreSubTest::MAIN_DATABASE_NAME = RDB_TEST_PATH + "subscribe.db";
103 std::shared_ptr<RdbStore> RdbStoreSubTest::store = nullptr;
104 std::shared_ptr<SubObserver> RdbStoreSubTest::observer_ = nullptr;
105 std::shared_ptr<StatisticsObserver> RdbStoreSubTest::sqlObserver_ = nullptr;
106
SetUpTestCase(void)107 void RdbStoreSubTest::SetUpTestCase(void)
108 {
109 RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME);
110 store = CreateRDB(1);
111 if (observer_ == nullptr) {
112 observer_ = std::make_shared<SubObserver>();
113 }
114 if (sqlObserver_ == nullptr) {
115 sqlObserver_ = std::make_shared<StatisticsObserver>();
116 }
117 }
118
TearDownTestCase(void)119 void RdbStoreSubTest::TearDownTestCase(void)
120 {
121 store = nullptr;
122 RdbHelper::DeleteRdbStore(MAIN_DATABASE_NAME);
123 }
124
SetUp()125 void RdbStoreSubTest::SetUp()
126 {
127 }
128
TearDown()129 void RdbStoreSubTest::TearDown()
130 {
131 }
132
133 class Callback : public RdbOpenCallback {
134 public:
135 int OnCreate(RdbStore &store) override;
136 int OnUpgrade(RdbStore &store, int oldVersion, int newVersion) override;
137 };
138
OnCreate(RdbStore & store)139 int Callback::OnCreate(RdbStore &store)
140 {
141 return E_OK;
142 }
143
OnUpgrade(RdbStore & store,int oldVersion,int newVersion)144 int Callback::OnUpgrade(RdbStore &store, int oldVersion, int newVersion)
145 {
146 return E_OK;
147 }
148
OnChange(const std::vector<std::string> & devices)149 void SubObserver::OnChange(const std::vector<std::string> &devices)
150 {
151 }
152
OnChange(const Origin & origin,const PrimaryFields & fields,RdbStoreObserver::ChangeInfo && changeInfo)153 void SubObserver::OnChange(const Origin &origin, const PrimaryFields &fields, RdbStoreObserver::ChangeInfo &&changeInfo)
154 {
155 count++;
156 if (checkOnChangeFunc_) {
157 checkOnChangeFunc_(changeInfo);
158 }
159 }
160
OnChange()161 void SubObserver::OnChange()
162 {
163 count++;
164 const std::string CREATE_TABLE_TEST = "CREATE TABLE IF NOT EXISTS test "
165 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
166 "name TEXT NOT NULL, age INTEGER, salary "
167 "REAL, blobType BLOB)";
168 RdbStoreSubTest::store->ExecuteSql(CREATE_TABLE_TEST);
169 ValuesBucket values;
170 int64_t id;
171 values.PutInt("id", count);
172 values.PutString("name", std::string("zhangsan"));
173 values.PutInt("age", 18);
174 values.PutDouble("salary", 100.5);
175 values.PutBlob("blobType", std::vector<uint8_t>{ 1, 2, 3 });
176 int ret = RdbStoreSubTest::store->Insert(id, "test", values);
177 EXPECT_EQ(ret, E_OK);
178 EXPECT_EQ(count, id);
179 }
180
RegisterCallback(const CheckOnChangeFunc & callback)181 void SubObserver::RegisterCallback(const CheckOnChangeFunc &callback)
182 {
183 checkOnChangeFunc_ = callback;
184 }
185
OnStatistic(const StatisticsObserver::SqlExecutionInfo & info)186 void StatisticsObserver::OnStatistic(const StatisticsObserver::SqlExecutionInfo &info)
187 {
188 }
189
Callback(const SqlStatisticsFunc & callback)190 void StatisticsObserver::Callback(const SqlStatisticsFunc &callback)
191 {
192 sqlStatisticsFunc_ = callback;
193 }
194
CreateRDB(int version)195 std::shared_ptr<RdbStore> RdbStoreSubTest::CreateRDB(int version)
196 {
197 RdbStoreConfig config(RdbStoreSubTest::MAIN_DATABASE_NAME);
198 config.SetBundleName("subscribe_test");
199 config.SetArea(0);
200 config.SetCreateNecessary(true);
201 config.SetDistributedType(RDB_DEVICE_COLLABORATION);
202 config.SetSecurityLevel(OHOS::NativeRdb::SecurityLevel::S1);
203 Callback helper;
204 int errCode = E_OK;
205 std::shared_ptr<RdbStore> store = RdbHelper::GetRdbStore(config, version, helper, errCode);
206 EXPECT_NE(store, nullptr);
207 return store;
208 }
209
RegisterCheckInsertCallback(const std::vector<std::shared_ptr<SubObserver>> & SubObservers)210 void RdbStoreSubTest::RegisterCheckInsertCallback(const std::vector<std::shared_ptr<SubObserver>> &SubObservers)
211 {
212 for (const auto &observer : SubObservers) {
213 observer->RegisterCallback([](RdbStoreObserver::ChangeInfo &changeInfo) {
214 ASSERT_EQ(changeInfo.size(), 1u);
215 EXPECT_TRUE(changeInfo["local_test"][1].empty());
216 EXPECT_TRUE(changeInfo["local_test"][2].empty()); // 2 is delete subscript
217 EXPECT_EQ(std::get<int64_t>(changeInfo["local_test"][0][0]), 1);
218 });
219 }
220 }
221
RegisterCheckUpdateCallback(const std::vector<std::shared_ptr<SubObserver>> & SubObservers)222 void RdbStoreSubTest::RegisterCheckUpdateCallback(const std::vector<std::shared_ptr<SubObserver>> &SubObservers)
223 {
224 for (const auto &observer : SubObservers) {
225 observer->RegisterCallback([](RdbStoreObserver::ChangeInfo &changeInfo) {
226 ASSERT_EQ(changeInfo.size(), 1u);
227 EXPECT_TRUE(changeInfo["local_test"][0].empty());
228 EXPECT_TRUE(changeInfo["local_test"][2].empty()); // 2 is delete subscript
229 EXPECT_EQ(std::get<int64_t>(changeInfo["local_test"][1][0]), 1);
230 });
231 }
232 }
233
234 /**
235 * @tc.name: RdbStoreSubscribeRemote
236 * @tc.desc: RdbStoreSubscribe
237 * @tc.type: FUNC
238 * @tc.require:
239 * @tc.author:
240 */
241 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeRemote, TestSize.Level1)
242 {
243 ASSERT_NE(store, nullptr) << "store is null";
244 EXPECT_NE(observer_, nullptr) << "observer is null";
245 auto status = store->Subscribe({ SubscribeMode::REMOTE, "observer" }, observer_);
246 EXPECT_EQ(status, E_OK);
247 status = store->UnSubscribe({ SubscribeMode::REMOTE, "observer" }, observer_);
248 EXPECT_EQ(status, E_OK);
249 }
250
251 /**
252 * @tc.name: RdbStoreSubscribeCloud
253 * @tc.desc: RdbStoreSubscribe
254 * @tc.type: FUNC
255 * @tc.require:
256 * @tc.author:
257 */
258 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeCloud, TestSize.Level1)
259 {
260 ASSERT_NE(store, nullptr) << "store is null";
261 EXPECT_NE(observer_, nullptr) << "observer is null";
262 auto status = store->Subscribe({ SubscribeMode::CLOUD, "observer" }, observer_);
263 EXPECT_EQ(status, E_OK);
264 status = store->UnSubscribe({ SubscribeMode::CLOUD, "observer" }, observer_);
265 EXPECT_EQ(status, E_OK);
266 }
267
268 /**
269 * @tc.name: RdbStoreSubscribeCloudDetail
270 * @tc.desc: RdbStoreSubscribe
271 * @tc.type: FUNC
272 * @tc.require:
273 * @tc.author:
274 */
275 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeCloudDetail, TestSize.Level1)
276 {
277 ASSERT_NE(store, nullptr) << "store is null";
278 EXPECT_NE(observer_, nullptr) << "observer is null";
279 auto status = store->Subscribe({ SubscribeMode::CLOUD_DETAIL, "observer" }, observer_);
280 EXPECT_EQ(status, E_OK);
281 status = store->UnSubscribe({ SubscribeMode::CLOUD_DETAIL, "observer" }, observer_);
282 EXPECT_EQ(status, E_OK);
283 }
284
285 /**
286 * @tc.name: RdbStoreSubscribeLocal
287 * @tc.desc: RdbStoreSubscribe
288 * @tc.type: FUNC
289 * @tc.require:
290 * @tc.author:
291 */
292 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocal, TestSize.Level1)
293 {
294 ASSERT_NE(store, nullptr) << "store is null";
295 EXPECT_NE(observer_, nullptr) << "observer is null";
296 auto status = store->Subscribe({ SubscribeMode::LOCAL, "observer1" }, observer_);
297 store->Subscribe({ SubscribeMode::LOCAL, "observer1" }, observer_);
298 EXPECT_EQ(status, E_OK);
299 store->Subscribe({ SubscribeMode::LOCAL, "observer2" }, observer_);
300 EXPECT_EQ(status, E_OK);
301
302 status = store->Notify("observer1");
303 EXPECT_EQ(status, E_OK);
304 status = store->Notify("observer2");
305 EXPECT_EQ(status, E_OK);
306 EXPECT_EQ(observer_->count, 2);
307
308 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM test");
309 int count;
310 resultSet->GetRowCount(count);
311 EXPECT_EQ(observer_->count, count);
312 status = store->UnSubscribe({ SubscribeMode::LOCAL, "nonexistent" }, observer_);
313 EXPECT_EQ(status, E_OK);
314 status = store->UnSubscribe({ SubscribeMode::LOCAL, "observer1" }, observer_);
315 EXPECT_EQ(status, E_OK);
316 status = store->UnSubscribe({ SubscribeMode::LOCAL, "nonexistent" }, nullptr);
317 EXPECT_EQ(status, E_OK);
318 status = store->UnSubscribe({ SubscribeMode::LOCAL, "observer2" }, nullptr);
319 EXPECT_EQ(status, E_OK);
320 status = store->Notify("observer1");
321 EXPECT_EQ(status, E_OK);
322 }
323
324 /**
325 * @tc.name: RdbStoreSubscribeLocalShared001
326 * @tc.desc: RdbStoreSubscribe
327 * @tc.type: FUNC
328 * @tc.require:
329 * @tc.author:
330 */
331 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalShared001, TestSize.Level1)
332 {
333 ASSERT_NE(store, nullptr) << "store is null";
334 EXPECT_NE(observer_, nullptr) << "observer is null";
335 auto status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "observer1" }, observer_);
336 EXPECT_EQ(status, E_OK);
337 status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "observer1" }, observer_);
338 EXPECT_EQ(status, E_OK);
339 status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "observer2" }, observer_);
340 EXPECT_EQ(status, E_OK);
341
342 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "nonexistent" }, observer_);
343 EXPECT_EQ(status, E_OK);
344 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "observer1" }, observer_);
345 EXPECT_EQ(status, E_OK);
346 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "nonexistent" }, nullptr);
347 EXPECT_EQ(status, E_OK);
348 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "observer2" }, nullptr);
349 EXPECT_EQ(status, E_OK);
350 }
351
352 /**
353 * @tc.name: RdbStoreSubscribeLocalShared002
354 * @tc.desc: RdbStoreSubscribe
355 * @tc.type: FUNC
356 * @tc.require:
357 * @tc.author:
358 */
359 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalShared002, TestSize.Level1)
360 {
361 ASSERT_NE(store, nullptr) << "store is null";
362 auto block = std::make_shared<OHOS::BlockData<bool>>(5, false);
__anon2a25c9390302() 363 auto callback = [block]() { block->SetValue(true); };
364 auto observer = std::make_shared<LocalShareObserver>(callback);
365 auto status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared002" }, observer);
366 EXPECT_EQ(status, E_OK);
367 status = store->Notify("RdbStoreSubscribeLocalShared002");
368 EXPECT_EQ(status, E_OK);
369 EXPECT_TRUE(block->GetValue());
370 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared002" }, observer);
371 }
372
373 /**
374 * @tc.name: RdbStoreSubscribeLocalShared003
375 * @tc.desc: RdbStoreSubscribe
376 * @tc.type: FUNC
377 * @tc.require:
378 * @tc.author:
379 */
380 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalShared003, TestSize.Level1)
381 {
382 ASSERT_NE(store, nullptr) << "store is null";
383 auto count = std::make_shared<std::atomic<int32_t>>(0);
__anon2a25c9390402() 384 auto callback = [count]() { count->fetch_add(1); };
385 auto observer = std::make_shared<LocalShareObserver>(callback);
386 auto status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared003" }, observer);
387 EXPECT_EQ(status, E_OK);
388 status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared003" }, observer);
389 EXPECT_EQ(status, E_OK);
390 status = store->Notify("RdbStoreSubscribeLocalShared003");
391 EXPECT_EQ(status, E_OK);
392 std::this_thread::sleep_for(std::chrono::seconds(3));
393 EXPECT_EQ(count->load(), 1);
394 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared003" }, observer);
395 EXPECT_EQ(status, E_OK);
396 }
397
398 /**
399 * @tc.name: RdbStoreSubscribeLocalShared004
400 * @tc.desc: UnSubscribe all
401 * @tc.type: FUNC
402 * @tc.require:
403 * @tc.author:
404 */
405 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalShared004, TestSize.Level1)
406 {
407 ASSERT_NE(store, nullptr) << "store is null";
408 auto count = std::make_shared<std::atomic<int32_t>>(0);
__anon2a25c9390502() 409 auto callback = [count]() { count->fetch_add(1); };
410 auto observer1 = std::make_shared<LocalShareObserver>(callback);
411 auto status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared004" }, observer1);
412 EXPECT_EQ(status, E_OK);
413 auto observer2 = std::make_shared<LocalShareObserver>(callback);
414 status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared004" }, observer2);
415 EXPECT_EQ(status, E_OK);
416 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared004" }, nullptr);
417 EXPECT_EQ(status, E_OK);
418 status = store->Notify("RdbStoreSubscribeLocalShared004");
419 EXPECT_EQ(status, E_OK);
420 std::this_thread::sleep_for(std::chrono::seconds(3));
421 EXPECT_EQ(count->load(), 0);
422 }
423
424 /**
425 * @tc.name: RdbStoreSubscribeLocalShared005
426 * @tc.desc: Subscribe after UnSubscribe
427 * @tc.type: FUNC
428 * @tc.require:
429 * @tc.author:
430 */
431 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalShared005, TestSize.Level1)
432 {
433 ASSERT_NE(store, nullptr) << "store is null";
434 auto block = std::make_shared<OHOS::BlockData<bool>>(3, false);
__anon2a25c9390602() 435 auto callback = [block]() { block->SetValue(true); };
436 auto observer = std::make_shared<LocalShareObserver>(callback);
437 auto status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared005" }, observer);
438 EXPECT_EQ(status, E_OK);
439 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared005" }, observer);
440 EXPECT_EQ(status, E_OK);
441 status = store->Notify("RdbStoreSubscribeLocalShared005");
442 EXPECT_EQ(status, E_OK);
443 EXPECT_FALSE(block->GetValue());
444
445 status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared005" }, observer);
446 EXPECT_EQ(status, E_OK);
447 block->Clear(false);
448 status = store->Notify("RdbStoreSubscribeLocalShared005");
449 EXPECT_EQ(status, E_OK);
450 EXPECT_TRUE(block->GetValue());
451 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared005" }, nullptr);
452 EXPECT_EQ(status, E_OK);
453 }
454
455 /**
456 * @tc.name: RdbStoreSubscribeLocalShared006
457 * @tc.desc: Different db Subscribe same uri
458 * @tc.type: FUNC
459 * @tc.require:
460 * @tc.author:
461 */
462 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalShared006, TestSize.Level1)
463 {
464 ASSERT_NE(store, nullptr) << "store is null";
465 RdbStoreConfig config(RDB_TEST_PATH + "RdbStoreSubscribeLocalShared006.db");
466 config.SetBundleName("subscribe_test");
467 Callback helper;
468 int errCode = E_ERROR;
469 std::shared_ptr<RdbStore> localStore = RdbHelper::GetRdbStore(config, 1, helper, errCode);
470 ASSERT_NE(localStore, nullptr);
471 ASSERT_EQ(errCode, E_OK);
472
473 auto count = std::make_shared<std::atomic<int32_t>>(0);
__anon2a25c9390702() 474 auto callback = [count]() { count->fetch_add(1); };
475 auto observer = std::make_shared<LocalShareObserver>(callback);
476 auto status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared006" }, observer);
477 EXPECT_EQ(status, E_OK);
478 status = localStore->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared006" }, observer);
479 EXPECT_EQ(status, E_OK);
480
481 status = store->Notify("RdbStoreSubscribeLocalShared006");
482 EXPECT_EQ(status, E_OK);
483 std::this_thread::sleep_for(std::chrono::seconds(3));
484 EXPECT_EQ(count->load(), 1);
485 status = localStore->Notify("RdbStoreSubscribeLocalShared006");
486 EXPECT_EQ(status, E_OK);
487 std::this_thread::sleep_for(std::chrono::seconds(3));
488 EXPECT_EQ(count->load(), 2);
489 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared006" }, nullptr);
490 EXPECT_EQ(status, E_OK);
491 EXPECT_EQ(RdbHelper::DeleteRdbStore(config), E_OK);
492 }
493
494 /**
495 * @tc.name: RdbStoreSubscribeLocalShared007
496 * @tc.desc: Subscribe to the same URI with different obs, then cancel all at once
497 * @tc.type: FUNC
498 * @tc.require:
499 * @tc.author:
500 */
501 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalShared007, TestSize.Level1)
502 {
503 ASSERT_NE(store, nullptr) << "store is null";
504 auto count = std::make_shared<std::atomic<int32_t>>(0);
__anon2a25c9390802() 505 auto callback = [count]() { count->fetch_add(1); };
506 auto observer1 = std::make_shared<LocalShareObserver>(callback);
507 auto status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared007" }, observer1);
508 EXPECT_EQ(status, E_OK);
509
510 auto observer2 = std::make_shared<LocalShareObserver>(callback);
511 status = store->Subscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared007" }, observer2);
512 EXPECT_EQ(status, E_OK);
513
514 status = store->Notify("RdbStoreSubscribeLocalShared007");
515 EXPECT_EQ(status, E_OK);
516 std::this_thread::sleep_for(std::chrono::seconds(3));
517 EXPECT_EQ(count->load(), 2);
518 status = store->UnSubscribe({ SubscribeMode::LOCAL_SHARED, "RdbStoreSubscribeLocalShared007" }, nullptr);
519 EXPECT_EQ(status, E_OK);
520
521 status = store->Notify("RdbStoreSubscribeLocalShared007");
522 EXPECT_EQ(status, E_OK);
523 std::this_thread::sleep_for(std::chrono::seconds(3));
524 EXPECT_EQ(count->load(), 2);
525 }
526
527 /**
528 * @tc.name: RdbStoreSubscribeLocalDetail001
529 * @tc.desc: test local observer onchange when insert data
530 * @tc.type: FUNC
531 * @tc.require:
532 * @tc.author:
533 */
534 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail001, TestSize.Level1)
535 {
536 ASSERT_NE(store, nullptr) << "store is null";
537 EXPECT_NE(observer_, nullptr) << "observer is null";
538 constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test "
539 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
540 "name TEXT NOT NULL, age INTEGER)";
541 store->ExecuteSql(createTableTest);
542 auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
543 EXPECT_EQ(status, E_OK);
544 EXPECT_EQ(status, E_OK);
545 auto observer2 = std::make_shared<SubObserver>();
546 status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
547
548 RegisterCheckInsertCallback({ observer_, observer2 });
549
550 ValuesBucket values;
551 int64_t id;
552 values.PutInt("id", 1);
553 values.PutString("name", std::string("zhangsan"));
554 values.PutInt("age", 18); // 18 is random age
555 status = store->Insert(id, "local_test", values);
556 EXPECT_EQ(status, E_OK);
557 EXPECT_EQ(id, 1);
558
__anon2a25c9390902(RdbStoreObserver::ChangeInfo &) 559 observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
__anon2a25c9390a02(RdbStoreObserver::ChangeInfo &) 560 observer2->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
561 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
562 EXPECT_EQ(status, E_OK);
563 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
564 EXPECT_EQ(status, E_OK);
565
566 ValuesBucket values2;
567 int id2;
568 values2.PutString("name", std::string("zhangsan_update1"));
569 values2.PutInt("age", 19); // 19 is random age
570 AbsRdbPredicates predicates("local_test");
571 predicates.EqualTo("id", 1);
572 status = store->Update(id2, values2, predicates);
573 EXPECT_EQ(status, E_OK);
574 EXPECT_EQ(id2, 1);
575 observer_->RegisterCallback(nullptr);
576 observer2->RegisterCallback(nullptr);
577 }
578
579 /**
580 * @tc.name: RdbStoreSubscribeLocalDetail002
581 * @tc.desc: test local observer onchange when update data
582 * @tc.type: FUNC
583 * @tc.require:
584 * @tc.author:
585 */
586 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail002, TestSize.Level1)
587 {
588 ASSERT_NE(store, nullptr) << "store is null";
589 EXPECT_NE(observer_, nullptr) << "observer is null";
590 auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
591 EXPECT_EQ(status, E_OK);
592 EXPECT_EQ(status, E_OK);
593 auto observer2 = std::make_shared<SubObserver>();
594 status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
595
596 RegisterCheckUpdateCallback({ observer_, observer2 });
597
598 int id;
599 ValuesBucket values;
600 values.PutString("name", std::string("zhangsan_update2"));
601 values.PutInt("age", 20); // 20 is random age
602 AbsRdbPredicates predicates("local_test");
603 predicates.EqualTo("id", 1);
604 status = store->Update(id, values, predicates);
605 EXPECT_EQ(status, E_OK);
606 EXPECT_EQ(id, 1);
607
__anon2a25c9390b02(RdbStoreObserver::ChangeInfo &) 608 observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
609 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
610 EXPECT_EQ(status, E_OK);
611
612 ValuesBucket values2;
613 int id2;
614 values2.PutString("name", std::string("zhangsan_update1"));
615 values2.PutInt("age", 19); // 19 is random age
616 AbsRdbPredicates predicates2("local_test");
617 predicates2.EqualTo("id", 1);
618 status = store->Update(id2, values2, predicates2);
619 EXPECT_EQ(status, E_OK);
620 EXPECT_EQ(id2, 1);
621 observer_->RegisterCallback(nullptr);
622 observer2->RegisterCallback(nullptr);
623 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer2);
624 EXPECT_EQ(status, E_OK);
625 }
626
627 /**
628 * @tc.name: RdbStoreSubscribeLocalDetail003
629 * @tc.desc: test local observer onchange when delete data
630 * @tc.type: FUNC
631 * @tc.require:
632 * @tc.author:
633 */
634 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail003, TestSize.Level1)
635 {
636 ASSERT_NE(store, nullptr) << "store is null";
637 EXPECT_NE(observer_, nullptr) << "observer is null";
638 auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
639 EXPECT_EQ(status, E_OK);
640
__anon2a25c9390c02(RdbStoreObserver::ChangeInfo &changeInfo) 641 observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &changeInfo) {
642 ASSERT_EQ(changeInfo.size(), 1u);
643 EXPECT_TRUE(changeInfo["local_test"][0].empty());
644 EXPECT_TRUE(changeInfo["local_test"][1].empty());
645 EXPECT_EQ(std::get<int64_t>(changeInfo["local_test"][2][0]), 1);
646 });
647
648 observer_->count = 0;
649 int id;
650 status = store->Delete(id, "local_test", "id = ?", std::vector<std::string>{ "1" });
651 EXPECT_EQ(status, E_OK);
652 EXPECT_EQ(id, 1);
653 EXPECT_EQ(observer_->count, 1);
654
655 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
656 EXPECT_EQ(status, E_OK);
657 observer_->RegisterCallback(nullptr);
658 }
659
660 /**
661 * @tc.name: RdbStoreSubscribeLocalDetail004
662 * @tc.desc: test local observer onchange when batchinsert data
663 * @tc.type: FUNC
664 * @tc.require:
665 * @tc.author:
666 */
667 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail004, TestSize.Level1)
668 {
669 int num = 10;
670 ASSERT_NE(store, nullptr) << "store is null";
671 EXPECT_NE(observer_, nullptr) << "observer is null";
672 auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
673 EXPECT_EQ(status, E_OK);
674
__anon2a25c9390d02(RdbStoreObserver::ChangeInfo &changeInfo) 675 observer_->RegisterCallback([num](RdbStoreObserver::ChangeInfo &changeInfo) {
676 ASSERT_EQ(changeInfo.size(), 1u);
677 EXPECT_TRUE(changeInfo["local_test"][1].empty());
678 EXPECT_TRUE(changeInfo["local_test"][2].empty()); // 2 is delete subscript
679 for (int i = 0; i < num; i++) {
680 EXPECT_EQ(std::get<int64_t>(changeInfo["local_test"][0][i]), i);
681 }
682 });
683
684 observer_->count = 0;
685 int64_t id;
686 std::vector<ValuesBucket> values;
687 for (int i = 0; i < num; i++) {
688 ValuesBucket value;
689 value.PutInt("id", i);
690 value.PutString("name", std::string("zhangsan"));
691 value.PutInt("age", 18); // 18 is random age
692 values.push_back(value);
693 }
694 status = store->BatchInsert(id, "local_test", values);
695 EXPECT_EQ(status, E_OK);
696 EXPECT_EQ(id, num);
697 EXPECT_EQ(observer_->count, 1);
698 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
699 EXPECT_EQ(status, E_OK);
700 observer_->RegisterCallback(nullptr);
701 }
702
703 /**
704 * @tc.name: RdbStoreSubscribeLocalDetail005
705 * @tc.desc: test local observer onchange when create table after register observer
706 * @tc.type: FUNC
707 * @tc.require:
708 * @tc.author:
709 */
710 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail005, TestSize.Level1)
711 {
712 int num = 1;
713 ASSERT_NE(store, nullptr) << "store is null";
714 EXPECT_NE(observer_, nullptr) << "observer is null";
715 auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
716 EXPECT_EQ(status, E_OK);
717 constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test1 "
718 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
719 "name TEXT NOT NULL, age INTEGER)";
720 store->ExecuteSql(createTableTest);
721
__anon2a25c9390e02(RdbStoreObserver::ChangeInfo &changeInfo) 722 observer_->RegisterCallback([num](RdbStoreObserver::ChangeInfo &changeInfo) {
723 ASSERT_EQ(changeInfo.size(), 1u);
724 EXPECT_TRUE(changeInfo["local_test1"][1].empty());
725 EXPECT_TRUE(changeInfo["local_test1"][2].empty()); // 2 is delete subscript
726 for (int i = 0; i < num; i++) {
727 EXPECT_EQ(std::get<int64_t>(changeInfo["local_test1"][0][i]), i);
728 }
729 });
730 observer_->count = 0;
731
732 int64_t id;
733 std::vector<ValuesBucket> values;
734 for (int i = 0; i < num; i++) {
735 ValuesBucket value;
736 value.PutInt("id", i);
737 value.PutString("name", std::string("zhangsan"));
738 value.PutInt("age", 18); // 18 is random age
739 values.push_back(value);
740 }
741 status = store->BatchInsert(id, "local_test1", values);
742 EXPECT_EQ(status, E_OK);
743 EXPECT_EQ(id, num);
744 EXPECT_EQ(observer_->count, 1);
745 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
746 EXPECT_EQ(status, E_OK);
747 status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
748 EXPECT_EQ(status, E_OK);
749 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, nullptr);
750 EXPECT_EQ(status, E_OK);
751 observer_->RegisterCallback(nullptr);
752 }
753
754 /**
755 * @tc.name: RdbStoreSubscribeLocalDetail006
756 * @tc.desc: test abnormal parametar subscribe
757 * @tc.type: FUNC
758 * @tc.require:
759 * @tc.author:
760 */
761 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail006, TestSize.Level1)
762 {
763 int num = 20;
764 ASSERT_NE(store, nullptr) << "store is null";
765 EXPECT_NE(observer_, nullptr) << "observer is null";
766 constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test2"
767 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
768 "name TEXT NOT NULL, age INTEGER)";
769 store->ExecuteSql(createTableTest);
770 auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
771 EXPECT_EQ(status, E_OK);
772
__anon2a25c9390f02(RdbStoreObserver::ChangeInfo &changeInfo) 773 observer_->RegisterCallback([num](RdbStoreObserver::ChangeInfo &changeInfo) {
774 ASSERT_EQ(changeInfo.size(), 1u);
775 EXPECT_TRUE(changeInfo["local_test2"][1].empty());
776 EXPECT_TRUE(changeInfo["local_test2"][2].empty()); // 2 is delete subscript
777 for (int i = 0; i < num; i++) {
778 EXPECT_EQ(std::get<int64_t>(changeInfo["local_test2"][0][i]), i);
779 }
780 });
781
782 observer_->count = 0;
783 std::vector<ValuesBucket> values;
784 for (int i = 0; i < num; i++) {
785 ValuesBucket value;
786 value.PutInt("id", i);
787 value.PutString("name", std::string("lisi"));
788 value.PutInt("age", 16);
789 values.push_back(value);
790 }
791 std::shared_ptr<Transaction> trans = nullptr;
792 std::tie(status, trans) = store->CreateTransaction(Transaction::DEFERRED);
793 EXPECT_EQ(status, E_OK);
794 int64_t insertRows = 0;
795 std::tie(status, insertRows) = trans->BatchInsert("local_test2", values);
796 EXPECT_EQ(status, E_OK);
797 EXPECT_EQ(insertRows, num);
798 EXPECT_EQ(observer_->count, 0);
799 trans->Commit();
800 trans = nullptr;
801 EXPECT_EQ(observer_->count, 1);
802 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
803 EXPECT_EQ(status, E_OK);
804 observer_->RegisterCallback(nullptr);
805 }
806
807 /**
808 * @tc.name: RdbStoreSubscribeLocalDetail007
809 * @tc.desc: test abnormal parametar subscribe
810 * @tc.type: FUNC
811 * @tc.require:
812 * @tc.author:
813 */
814 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail007, TestSize.Level1)
815 {
816 int num = 20;
817 ASSERT_NE(store, nullptr) << "store is null";
818 EXPECT_NE(observer_, nullptr) << "observer is null";
819 constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test3"
820 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
821 "name TEXT NOT NULL, age INTEGER)";
822 store->ExecuteSql(createTableTest);
823 std::shared_ptr<Transaction> trans1 = nullptr;
824 int status = 0;
825 std::tie(status, trans1) = store->CreateTransaction(Transaction::DEFERRED);
826 EXPECT_EQ(status, E_OK);
827 status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
828 EXPECT_EQ(status, E_OK);
829 trans1 = nullptr;
__anon2a25c9391002(RdbStoreObserver::ChangeInfo &changeInfo) 830 observer_->RegisterCallback([num](RdbStoreObserver::ChangeInfo &changeInfo) {
831 ASSERT_EQ(changeInfo.size(), 1u);
832 EXPECT_TRUE(changeInfo["local_test3"][1].empty());
833 EXPECT_TRUE(changeInfo["local_test3"][2].empty()); // 2 is delete subscript
834 for (int i = 0; i < num; i++) {
835 EXPECT_EQ(std::get<int64_t>(changeInfo["local_test3"][0][i]), i);
836 }
837 });
838
839 observer_->count = 0;
840 std::vector<ValuesBucket> values;
841 for (int i = 0; i < num; i++) {
842 ValuesBucket value;
843 value.PutInt("id", i);
844 value.PutString("name", std::string("lisi"));
845 value.PutInt("age", 16);
846 values.push_back(value);
847 }
848 std::shared_ptr<Transaction> trans2 = nullptr;
849 std::tie(status, trans2) = store->CreateTransaction(Transaction::DEFERRED);
850 EXPECT_EQ(status, E_OK);
851 int64_t insertRows = 0;
852 std::tie(status, insertRows) = trans2->BatchInsert("local_test3", values);
853 EXPECT_EQ(status, E_OK);
854 EXPECT_EQ(insertRows, num);
855 EXPECT_EQ(observer_->count, 0);
856 trans2->Commit();
857 trans2 = nullptr;
858 EXPECT_EQ(observer_->count, 1);
859 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
860 EXPECT_EQ(status, E_OK);
861 observer_->RegisterCallback(nullptr);
862 }
863
864 /**
865 * @tc.name: RdbStoreSubscribeLocalDetail008
866 * @tc.desc: test abnormal parametar subscribe
867 * @tc.type: FUNC
868 * @tc.require:
869 * @tc.author:
870 */
871 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail008, TestSize.Level1)
872 {
873 int num = 20;
874 ASSERT_NE(store, nullptr) << "store is null";
875 EXPECT_NE(observer_, nullptr) << "observer is null";
876 constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS local_test4"
877 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
878 "name TEXT NOT NULL, age INTEGER)";
879 store->ExecuteSql(createTableTest);
880 auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
881 EXPECT_EQ(status, E_OK);
882
__anon2a25c9391102(RdbStoreObserver::ChangeInfo &) 883 observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
884
885 observer_->count = 0;
886 std::vector<ValuesBucket> values;
887 for (int i = 0; i < num; i++) {
888 ValuesBucket value;
889 value.PutInt("id", i);
890 value.PutString("name", std::string("lisi"));
891 value.PutInt("age", 16);
892 values.push_back(value);
893 }
894 std::shared_ptr<Transaction> trans = nullptr;
895 std::tie(status, trans) = store->CreateTransaction(Transaction::DEFERRED);
896 EXPECT_EQ(status, E_OK);
897 int64_t insertRows = 0;
898 std::tie(status, insertRows) = trans->BatchInsert("local_test4", values);
899 EXPECT_EQ(status, E_OK);
900 EXPECT_EQ(insertRows, num);
901 EXPECT_EQ(observer_->count, 0);
902 status = store->UnsubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, observer_);
903 EXPECT_EQ(status, E_OK);
904 trans->Commit();
905 trans = nullptr;
906 EXPECT_EQ(observer_->count, 0);
907 observer_->RegisterCallback(nullptr);
908 }
909
910 /**
911 * @tc.name: RdbStoreSubscribeLocalDetail009
912 * @tc.desc: test abnormal parametar subscribe
913 * @tc.type: FUNC
914 * @tc.require:
915 * @tc.author:
916 */
917 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeLocalDetail009, TestSize.Level1)
918 {
919 ASSERT_NE(store, nullptr) << "store is null";
920 EXPECT_NE(observer_, nullptr) << "observer is null";
921 auto status = store->SubscribeObserver({ SubscribeMode::LOCAL_DETAIL, "dataChange" }, nullptr);
922 EXPECT_EQ(status, E_OK);
__anon2a25c9391202(RdbStoreObserver::ChangeInfo &) 923 observer_->RegisterCallback([](RdbStoreObserver::ChangeInfo &) { ASSERT_TRUE(false); });
924 ValuesBucket values;
925 int id;
926 values.PutString("name", std::string("zhangsan_update1"));
927 values.PutInt("age", 19); // 19 is random age
928 AbsRdbPredicates predicates("local_test");
929 predicates.EqualTo("id", 1);
930 status = store->Update(id, values, predicates);
931 EXPECT_EQ(status, E_OK);
932 EXPECT_EQ(id, 1); // 2 is random id
933 observer_->RegisterCallback(nullptr);
934 }
935
936 /**
937 * @tc.name: RdbStoreSubscribeStatistics001
938 * @tc.desc: test statistics observer when insert data
939 * @tc.type: FUNC
940 * @tc.require:
941 * @tc.author:
942 */
943 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics001, TestSize.Level1)
944 {
945 ASSERT_NE(store, nullptr) << "store is null";
946 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
947 constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS statistics_test "
948 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
949 "name TEXT NOT NULL, age INTEGER)";
950 store->ExecuteSql(createTableTest);
951 auto status = SqlStatistic::Subscribe(sqlObserver_);
952 EXPECT_EQ(status, E_OK);
953 auto observer2 = std::make_shared<StatisticsObserver>();
954 status = SqlStatistic::Subscribe(sqlObserver_);
955 ValuesBucket values;
956 int64_t id;
957 values.PutInt("id", 1);
958 values.PutString("name", std::string("zhangsan"));
959 values.PutInt("age", 18); // 18 is random age
960 status = store->Insert(id, "statistics_test", values);
961 EXPECT_EQ(status, E_OK);
962 EXPECT_EQ(id, 1);
__anon2a25c9391302(SqlObserver::SqlExecutionInfo &info) 963 sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
__anon2a25c9391402(SqlObserver::SqlExecutionInfo &info) 964 observer2->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
965 status = SqlStatistic::Unsubscribe(sqlObserver_);
966 EXPECT_EQ(status, E_OK);
967 status = SqlStatistic::Unsubscribe(observer2);
968 EXPECT_EQ(status, E_OK);
969 }
970
971 /**
972 * @tc.name: RdbStoreSubscribeStatistics002
973 * @tc.desc: test statistics observer when update data
974 * @tc.type: FUNC
975 * @tc.require:
976 * @tc.author:
977 */
978 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics002, TestSize.Level1)
979 {
980 ASSERT_NE(store, nullptr) << "store is null";
981 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
982 auto status = SqlStatistic::Subscribe(sqlObserver_);
983 EXPECT_EQ(status, E_OK);
984 int id;
985 ValuesBucket values;
986 values.PutString("name", std::string("zhangsan_update2"));
987 values.PutInt("age", 20); // 20 is random age
988 AbsRdbPredicates predicates("statistics_test");
989 predicates.EqualTo("id", 1);
990 status = store->Update(id, values, predicates);
991 EXPECT_EQ(status, E_OK);
992 EXPECT_EQ(id, 1);
__anon2a25c9391502(SqlObserver::SqlExecutionInfo &info) 993 sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
994 status = SqlStatistic::Unsubscribe(sqlObserver_);
995 EXPECT_EQ(status, E_OK);
996 }
997
998 /**
999 * @tc.name: RdbStoreSubscribeStatistics003
1000 * @tc.desc: test statistics observer when delete data
1001 * @tc.type: FUNC
1002 * @tc.require:
1003 * @tc.author:
1004 */
1005 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics003, TestSize.Level1)
1006 {
1007 ASSERT_NE(store, nullptr) << "store is null";
1008 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
1009 auto status = SqlStatistic::Subscribe(sqlObserver_);
1010 EXPECT_EQ(status, E_OK);
__anon2a25c9391602(SqlObserver::SqlExecutionInfo &info) 1011 sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
1012 int id;
1013 status = store->Delete(id, "statistics_test", "id = ?", std::vector<std::string>{ "1" });
1014 EXPECT_EQ(status, E_OK);
1015 EXPECT_EQ(id, 1);
1016
1017 status = SqlStatistic::Unsubscribe(sqlObserver_);
1018 EXPECT_EQ(status, E_OK);
1019 sqlObserver_->Callback(nullptr);
1020 }
1021
1022 /**
1023 * @tc.name: RdbStoreSubscribeStatistics001
1024 * @tc.desc: test statistics observer when batchinsert data
1025 * @tc.type: FUNC
1026 * @tc.require:
1027 * @tc.author:
1028 */
1029 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics004, TestSize.Level1)
1030 {
1031 int num = 10;
1032 ASSERT_NE(store, nullptr) << "store is null";
1033 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
1034 auto status = SqlStatistic::Subscribe(sqlObserver_);
1035 EXPECT_EQ(status, E_OK);
__anon2a25c9391702(SqlObserver::SqlExecutionInfo &info) 1036 sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 1); });
1037 int64_t id;
1038 std::vector<ValuesBucket> values;
1039 for (int i = 0; i < num; i++) {
1040 ValuesBucket value;
1041 value.PutInt("id", i);
1042 value.PutString("name", std::string("zhangsan"));
1043 value.PutInt("age", 18); // 18 is random age
1044 values.push_back(value);
1045 }
1046 status = store->BatchInsert(id, "statistics_test", values);
1047 EXPECT_EQ(status, E_OK);
1048 EXPECT_EQ(id, num);
1049 status = SqlStatistic::Unsubscribe(sqlObserver_);
1050 EXPECT_EQ(status, E_OK);
1051 }
1052
1053 /**
1054 * @tc.name: RdbStoreSubscribeStatistics001
1055 * @tc.desc: test statistics observer when create table after register observer
1056 * @tc.type: FUNC
1057 * @tc.require:
1058 * @tc.author:
1059 */
1060 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics005, TestSize.Level1)
1061 {
1062 ASSERT_NE(store, nullptr) << "store is null";
1063 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
1064 auto status = SqlStatistic::Subscribe(sqlObserver_);
1065 EXPECT_EQ(status, E_OK);
1066 constexpr const char *createTableTest = "CREATE TABLE IF NOT EXISTS statistics_test1 "
1067 "(id INTEGER PRIMARY KEY AUTOINCREMENT, "
1068 "name TEXT NOT NULL, age INTEGER)";
1069 store->ExecuteSql(createTableTest);
1070
__anon2a25c9391802(SqlObserver::SqlExecutionInfo &info) 1071 sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 3); });
1072 ValuesBucket values;
1073 int64_t id;
1074 values.PutInt("id", 1);
1075 values.PutString("name", std::string("zhangsan"));
1076 values.PutInt("age", 18); // 18 is random age
1077 status = store->Insert(id, "statistics_test1", values);
1078 EXPECT_EQ(status, E_OK);
1079 EXPECT_EQ(id, 1);
1080 status = SqlStatistic::Unsubscribe(sqlObserver_);
1081 EXPECT_EQ(status, E_OK);
1082 }
1083
1084 /**
1085 * @tc.name: RdbStoreSubscribeStatistics006
1086 * @tc.desc: test statistics observer when query data
1087 * @tc.type: FUNC
1088 * @tc.require:
1089 * @tc.author:
1090 */
1091 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics006, TestSize.Level1)
1092 {
1093 ASSERT_NE(store, nullptr) << "store is null";
1094 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
1095 auto status = SqlStatistic::Subscribe(sqlObserver_);
1096 EXPECT_EQ(status, E_OK);
__anon2a25c9391902(SqlObserver::SqlExecutionInfo &info) 1097 sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 2); });
1098 std::shared_ptr<ResultSet> resultSet = store->QueryByStep("SELECT * FROM statistics_test");
1099 EXPECT_NE(resultSet, nullptr);
1100 status = SqlStatistic::Unsubscribe(sqlObserver_);
1101 EXPECT_EQ(status, E_OK);
1102 }
1103
1104 /**
1105 * @tc.name: RdbStoreSubscribeStatistics007
1106 * @tc.desc: test statistics observer when query data
1107 * @tc.type: FUNC
1108 * @tc.require:
1109 * @tc.author:
1110 */
1111 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics007, TestSize.Level1)
1112 {
1113 ASSERT_NE(store, nullptr) << "store is null";
1114 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
1115 auto status = SqlStatistic::Subscribe(sqlObserver_);
1116 EXPECT_EQ(status, E_OK);
__anon2a25c9391a02(SqlObserver::SqlExecutionInfo &info) 1117 sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_.size(), 2); });
1118 std::shared_ptr<ResultSet> resultSet = store->QuerySql("SELECT * FROM statistics_test");
1119 EXPECT_NE(resultSet, nullptr);
1120 status = SqlStatistic::Unsubscribe(sqlObserver_);
1121 EXPECT_EQ(status, E_OK);
1122 }
1123
1124 /**
1125 * @tc.name: RdbStoreSubscribeStatistics008
1126 * @tc.desc: test statistics observer when Execute pragma
1127 * @tc.type: FUNC
1128 * @tc.require:
1129 * @tc.author:
1130 */
1131 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics008, TestSize.Level1)
1132 {
1133 ASSERT_NE(store, nullptr) << "store is null";
1134 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
1135 auto status = SqlStatistic::Subscribe(sqlObserver_);
1136 EXPECT_EQ(status, E_OK);
__anon2a25c9391b02(SqlObserver::SqlExecutionInfo &info) 1137 sqlObserver_->Callback([](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_[0], "PRAGMA quick_check"); });
1138 auto [ret, object] = store->Execute("PRAGMA quick_check");
1139 status = SqlStatistic::Unsubscribe(sqlObserver_);
1140 EXPECT_EQ(status, E_OK);
1141 }
1142
1143 /**
1144 * @tc.name: RdbStoreSubscribeStatistics009
1145 * @tc.desc: test statistics observer when ExecuteSql
1146 * @tc.type: FUNC
1147 * @tc.require:
1148 * @tc.author:
1149 */
1150 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics009, TestSize.Level1)
1151 {
1152 ASSERT_NE(store, nullptr) << "store is null";
1153 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
1154 std::string value = "with test as (select * from statistics_test) select * from test1";
1155 auto status = SqlStatistic::Subscribe(sqlObserver_);
1156 EXPECT_EQ(status, E_OK);
__anon2a25c9391c02(SqlObserver::SqlExecutionInfo &info) 1157 sqlObserver_->Callback([value](SqlObserver::SqlExecutionInfo &info) { ASSERT_EQ(info.sql_[0], value); });
1158 store->ExecuteSql(value);
1159 status = SqlStatistic::Unsubscribe(sqlObserver_);
1160 EXPECT_EQ(status, E_OK);
1161 }
1162
1163 /**
1164 * @tc.name: RdbStoreSubscribeStatistics010
1165 * @tc.desc: test abnormal parametar subscribe
1166 * @tc.type: FUNC
1167 * @tc.require:
1168 * @tc.author:
1169 */
1170 HWTEST_F(RdbStoreSubTest, RdbStoreSubscribeStatistics010, TestSize.Level1)
1171 {
1172 ASSERT_NE(store, nullptr) << "store is null";
1173 EXPECT_NE(sqlObserver_, nullptr) << "observer is null";
1174 auto status = SqlStatistic::Subscribe(nullptr);
1175 EXPECT_EQ(status, E_OK);
1176 }
1177
1178 /**
1179 * @tc.name: RdbStore_RegisterAutoSyncCallbackAndRdbStore_UnregisterAutoSyncCallback_001
1180 * @tc.desc: Test RegisterAutoSyncCallback and UnregisterAutoSyncCallback
1181 * @tc.type: FUNC
1182 */
1183 HWTEST_F(RdbStoreSubTest, RdbStore_RegisterAutoSyncCallbackAndRdbStore_UnregisterAutoSyncCallback_001, TestSize.Level1)
1184 {
1185 ASSERT_NE(store, nullptr) << "store is null";
1186 auto obs = std::make_shared<TestDetailProgressObserver>();
1187 auto status = store->RegisterAutoSyncCallback(obs);
1188 EXPECT_EQ(status, E_OK);
1189
1190 status = store->UnregisterAutoSyncCallback(obs);
1191 EXPECT_EQ(status, E_OK);
1192 }
1193