1 /*
2 * Copyright (c) 2024 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 "db_constant.h"
18 #include "db_common.h"
19 #include "distributeddb_tools_unit_test.h"
20 #include "meta_data.h"
21 #include "virtual_single_ver_sync_db_Interface.h"
22
23 using namespace testing::ext;
24 using namespace testing;
25 using namespace DistributedDB;
26 using namespace DistributedDBUnitTest;
27
28 namespace {
29 constexpr const char *DEVICE_A = "deviceA";
30 constexpr const char *DEVICE_B = "deviceB";
31 constexpr const char *USER_A = "userA";
32 constexpr const char *USER_B = "userB";
33 class DistributedDBMetaDataTest : public testing::Test {
34 public:
35 static void SetUpTestCase();
36 static void TearDownTestCase();
37 void SetUp();
38 void TearDown();
39 void GetMetaDataValue(const std::string &hashDeviceId, MetaDataValue &metaDataValue);
40 void PutMetaDataValue(const std::string &hashDeviceId, MetaDataValue &metaDataValue);
41 protected:
42 std::shared_ptr<Metadata> metadata_ = nullptr;
43 VirtualSingleVerSyncDBInterface *storage_ = nullptr;
44 };
45
SetUpTestCase()46 void DistributedDBMetaDataTest::SetUpTestCase()
47 {
48 }
49
TearDownTestCase()50 void DistributedDBMetaDataTest::TearDownTestCase()
51 {
52 }
53
SetUp()54 void DistributedDBMetaDataTest::SetUp()
55 {
56 DistributedDBToolsUnitTest::PrintTestCaseInfo();
57 metadata_ = std::make_shared<Metadata>();
58 ASSERT_NE(metadata_, nullptr);
59 storage_ = new(std::nothrow) VirtualSingleVerSyncDBInterface();
60 ASSERT_NE(storage_, nullptr);
61 metadata_->Initialize(storage_);
62 }
63
TearDown()64 void DistributedDBMetaDataTest::TearDown()
65 {
66 metadata_ = nullptr;
67 if (storage_ != nullptr) {
68 delete storage_;
69 storage_ = nullptr;
70 }
71 }
72
GetMetaDataValue(const std::string & hashDeviceId,MetaDataValue & metaDataValue)73 void DistributedDBMetaDataTest::GetMetaDataValue(const std::string &hashDeviceId, MetaDataValue &metaDataValue)
74 {
75 Key key;
76 DBCommon::StringToVector(hashDeviceId, key);
77 Value value;
78 int errCode = storage_->GetMetaData(key, value);
79 if (errCode == -E_NOT_FOUND) {
80 return;
81 }
82 EXPECT_EQ(errCode, E_OK);
83 EXPECT_EQ(memcpy_s(&metaDataValue, sizeof(MetaDataValue), value.data(), value.size()), EOK);
84 }
85
PutMetaDataValue(const std::string & hashDeviceId,MetaDataValue & metaDataValue)86 void DistributedDBMetaDataTest::PutMetaDataValue(const std::string &hashDeviceId, MetaDataValue &metaDataValue)
87 {
88 Key key;
89 DBCommon::StringToVector(hashDeviceId, key);
90 Value value;
91 value.resize(sizeof(MetaDataValue));
92 EXPECT_EQ(memcpy_s(value.data(), value.size(), &metaDataValue, sizeof(MetaDataValue)), EOK);
93 EXPECT_EQ(storage_->PutMetaData(key, value, false), E_OK);
94 }
95
96 /**
97 * @tc.name: MetadataTest001
98 * @tc.desc: Test metadata set and get ability sync mark.
99 * @tc.type: FUNC
100 * @tc.require:
101 * @tc.author: zhangqiquan
102 */
103 HWTEST_F(DistributedDBMetaDataTest, MetadataTest001, TestSize.Level0)
104 {
105 /**
106 * @tc.steps: step1. Check ability sync finish before set mark.
107 * @tc.expected: step1. Default all ability sync finish is false.
108 */
109 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, ""));
110 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_B, ""));
111 /**
112 * @tc.steps: step2. Set A ability sync finish.
113 * @tc.expected: step2. A is finish B is not finish.
114 */
115 EXPECT_EQ(metadata_->SetAbilitySyncFinishMark(DEVICE_A, "", true), E_OK);
116 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, ""));
117 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_B, ""));
118 /**
119 * @tc.steps: step3. Set B ability sync finish.
120 * @tc.expected: step3. A and B is finish.
121 */
122 EXPECT_EQ(metadata_->SetAbilitySyncFinishMark(DEVICE_B, "", true), E_OK);
123 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, ""));
124 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_B, ""));
125 /**
126 * @tc.steps: step4. Set A ability sync not finish.
127 * @tc.expected: step4. A is not finish B is finish.
128 */
129 EXPECT_EQ(metadata_->SetAbilitySyncFinishMark(DEVICE_A, "", false), E_OK);
130 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, ""));
131 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_B, ""));
132 /**
133 * @tc.steps: step5. Clear all time sync finish.
134 * @tc.expected: step5. A and B is finish.
135 */
136 EXPECT_EQ(metadata_->ClearAllTimeSyncFinishMark(), E_OK);
137 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, ""));
138 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_B, ""));
139 /**
140 * @tc.steps: step6. Clear all ability sync finish.
141 * @tc.expected: step6. A and B is not finish.
142 */
143 EXPECT_EQ(metadata_->ClearAllAbilitySyncFinishMark(), E_OK);
144 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, ""));
145 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_B, ""));
146 }
147
148 /**
149 * @tc.name: MetadataTest002
150 * @tc.desc: Test metadata set and get time sync mark.
151 * @tc.type: FUNC
152 * @tc.require:
153 * @tc.author: zhangqiquan
154 */
155 HWTEST_F(DistributedDBMetaDataTest, MetadataTest002, TestSize.Level0)
156 {
157 /**
158 * @tc.steps: step1. Check time sync finish before set mark.
159 * @tc.expected: step1. Default all time sync finish is false.
160 */
161 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, ""));
162 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_B, ""));
163 /**
164 * @tc.steps: step2. Set A time sync finish.
165 * @tc.expected: step2. A is finish B is not finish.
166 */
167 EXPECT_EQ(metadata_->SetTimeSyncFinishMark(DEVICE_A, "", true), E_OK);
168 EXPECT_TRUE(metadata_->IsTimeSyncFinish(DEVICE_A, ""));
169 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_B, ""));
170 /**
171 * @tc.steps: step3. Set B time sync finish.
172 * @tc.expected: step3. A and B is finish.
173 */
174 EXPECT_EQ(metadata_->SetTimeSyncFinishMark(DEVICE_B, "", true), E_OK);
175 EXPECT_TRUE(metadata_->IsTimeSyncFinish(DEVICE_A, ""));
176 EXPECT_TRUE(metadata_->IsTimeSyncFinish(DEVICE_B, ""));
177 /**
178 * @tc.steps: step4. Set A time sync not finish.
179 * @tc.expected: step4. A is not finish B is finish.
180 */
181 EXPECT_EQ(metadata_->SetTimeSyncFinishMark(DEVICE_A, "", false), E_OK);
182 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, ""));
183 EXPECT_TRUE(metadata_->IsTimeSyncFinish(DEVICE_B, ""));
184 /**
185 * @tc.steps: step5. Clear all time sync finish.
186 * @tc.expected: step5. A and B is not finish.
187 */
188 EXPECT_EQ(metadata_->ClearAllTimeSyncFinishMark(), E_OK);
189 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, ""));
190 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_B, ""));
191 }
192
193 /**
194 * @tc.name: MetadataTest003
195 * @tc.desc: Test metadata set remote schema version.
196 * @tc.type: FUNC
197 * @tc.require:
198 * @tc.author: zhangqiquan
199 */
200 HWTEST_F(DistributedDBMetaDataTest, MetadataTest003, TestSize.Level0)
201 {
202 /**
203 * @tc.steps: step1. Check remote schema version before set version.
204 * @tc.expected: step1. Default all version is zero.
205 */
206 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, ""), 0u);
207 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_B, ""), 0u);
208 /**
209 * @tc.steps: step2. Set A schema version.
210 * @tc.expected: step2. A is finish B is not finish.
211 */
212 EXPECT_EQ(metadata_->SetRemoteSchemaVersion(DEVICE_A, "", SOFTWARE_VERSION_CURRENT), E_OK);
213 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, ""), SOFTWARE_VERSION_CURRENT);
214 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_B, ""), 0u);
215 /**
216 * @tc.steps: step3. Clear all ability sync finish.
217 * @tc.expected: step3. A and B version is zero.
218 */
219 EXPECT_EQ(metadata_->ClearAllAbilitySyncFinishMark(), E_OK);
220 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, ""), 0u);
221 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_B, ""), 0u);
222 }
223
224 /**
225 * @tc.name: MetadataTest004
226 * @tc.desc: Test metadata set remote system time off set.
227 * @tc.type: FUNC
228 * @tc.require:
229 * @tc.author: zhangqiquan
230 */
231 HWTEST_F(DistributedDBMetaDataTest, MetadataTest004, TestSize.Level0)
232 {
233 /**
234 * @tc.steps: step1. Check remote schema version before set version.
235 * @tc.expected: step1. Default all version is zero.
236 */
237 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, ""), 0u);
238 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_B, ""), 0u);
239 /**
240 * @tc.steps: step2. Set A schema version.
241 * @tc.expected: step2. A is finish B is not finish.
242 */
243 const int64_t offset = 100u;
244 EXPECT_EQ(metadata_->SetSystemTimeOffset(DEVICE_A, "", offset), E_OK);
245 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, ""), offset);
246 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_B, ""), 0u);
247 /**
248 * @tc.steps: step3. Clear all time sync finish.
249 * @tc.expected: step3. A and B system time offset is zero.
250 */
251 EXPECT_EQ(metadata_->ClearAllTimeSyncFinishMark(), E_OK);
252 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, ""), 0u);
253 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_B, ""), 0u);
254 }
255
256 /**
257 * @tc.name: MetadataTest005
258 * @tc.desc: Test metadata set local schema version.
259 * @tc.type: FUNC
260 * @tc.require:
261 * @tc.author: zhangqiquan
262 */
263 HWTEST_F(DistributedDBMetaDataTest, MetadataTest005, TestSize.Level0)
264 {
265 /**
266 * @tc.steps: step1. Check local schema version before set version.
267 * @tc.expected: step1. Default all version is zero.
268 */
269 auto res = metadata_->GetLocalSchemaVersion();
270 EXPECT_EQ(res.first, E_OK);
271 EXPECT_NE(res.second, 0u);
272 /**
273 * @tc.steps: step2. Set local schema version.
274 * @tc.expected: step2. set success.
275 */
276 EXPECT_EQ(metadata_->SetLocalSchemaVersion(SOFTWARE_VERSION_CURRENT), E_OK);
277 res = metadata_->GetLocalSchemaVersion();
278 EXPECT_EQ(res.first, E_OK);
279 EXPECT_EQ(res.second, SOFTWARE_VERSION_CURRENT);
280 }
281
282 /**
283 * @tc.name: MetadataTest006
284 * @tc.desc: Test metadata remove device data with reload.
285 * @tc.type: FUNC
286 * @tc.require:
287 * @tc.author: zhangqiquan
288 */
289 HWTEST_F(DistributedDBMetaDataTest, MetadataTest006, TestSize.Level0)
290 {
291 /**
292 * @tc.steps: step1. Set storage ability sync finish.
293 * @tc.expected: step1. A is finish.
294 */
295 std::string hashDeviceId = DBConstant::DEVICEID_PREFIX_KEY + DBCommon::TransferHashString(DEVICE_A) +
296 DBConstant::USERID_PREFIX_KEY + "";
297 MetaDataValue metaDataValue;
298 GetMetaDataValue(hashDeviceId, metaDataValue);
299 EXPECT_EQ(metaDataValue.syncMark & static_cast<uint64_t>(SyncMark::SYNC_MARK_ABILITY_SYNC), 0u);
300 metaDataValue.syncMark = static_cast<uint64_t>(SyncMark::SYNC_MARK_ABILITY_SYNC);
301 PutMetaDataValue(hashDeviceId, metaDataValue);
302 /**
303 * @tc.steps: step2. Check ability sync finish by meta.
304 * @tc.expected: step2. A is finish because meta data is loaded from db.
305 */
306 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, ""));
307 /**
308 * @tc.steps: step3. Erase water mark and check again.
309 * @tc.expected: step3. A is finish because meta data is loaded from db.
310 */
311 EXPECT_EQ(metadata_->EraseDeviceWaterMark(DEVICE_A, true), E_OK);
312 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, ""));
313 }
314
315 /**
316 * @tc.name: MetadataTest007
317 * @tc.desc: Test metadata init with time change if need.
318 * @tc.type: FUNC
319 * @tc.require:
320 * @tc.author: zhangqiquan
321 */
322 HWTEST_F(DistributedDBMetaDataTest, MetadataTest007, TestSize.Level0)
323 {
324 /**
325 * @tc.steps: step1. Check time sync finish by meta.
326 * @tc.expected: step1. B is change because of time change.
327 */
328 RuntimeContext::GetInstance()->SetTimeChanged(true);
329 EXPECT_TRUE(metadata_->IsTimeChange(DEVICE_B, ""));
330 RuntimeContext::GetInstance()->SetTimeChanged(false);
331 RuntimeContext::GetInstance()->StopTimeTickMonitorIfNeed();
332 }
333
334 /**
335 * @tc.name: MetadataTest008
336 * @tc.desc: Test metadata deserialize v1 local meta.
337 * @tc.type: FUNC
338 * @tc.require:
339 * @tc.author: zhangqiquan
340 */
341 HWTEST_F(DistributedDBMetaDataTest, MetadataTest008, TestSize.Level0)
342 {
343 /**
344 * @tc.steps: step1. Insert v1 local meta data.
345 * @tc.expected: step1.Insert OK.
346 */
347 std::string keyStr = "localMetaData";
348 Key key(keyStr.begin(), keyStr.end());
349 Value value;
350 value.resize(Parcel::GetUInt32Len() + Parcel::GetUInt64Len());
351 Parcel parcel(value.data(), value.size());
352 LocalMetaData expectLocalMetaData;
353 expectLocalMetaData.version = LOCAL_META_DATA_VERSION_V1;
354 expectLocalMetaData.localSchemaVersion = SOFTWARE_VERSION_RELEASE_9_0;
355 (void)parcel.WriteUInt32(expectLocalMetaData.version);
356 (void)parcel.WriteUInt64(expectLocalMetaData.localSchemaVersion);
357 ASSERT_FALSE(parcel.IsError());
358 ASSERT_EQ(storage_->PutMetaData(key, value, false), E_OK);
359 /**
360 * @tc.steps: step2. Read v1 local meta data.
361 * @tc.expected: step2.Read OK.
362 */
363 auto res = metadata_->GetLocalSchemaVersion();
364 EXPECT_EQ(res.first, E_OK);
365 EXPECT_EQ(res.second, expectLocalMetaData.localSchemaVersion);
366 }
367
368 /**
369 * @tc.name: MetadataTest009
370 * @tc.desc: Test initially saved metadata after time changed.
371 * @tc.type: FUNC
372 * @tc.require:
373 * @tc.author: chenghuitao
374 */
375 HWTEST_F(DistributedDBMetaDataTest, MetadataTest009, TestSize.Level0)
376 {
377 /**
378 * @tc.steps: step1. Check time changed after metadata is saved initially by SetDbCreateTime.
379 * @tc.expected: step1. B is change because of time change.
380 */
381 RuntimeContext::GetInstance()->SetTimeChanged(true);
382 EXPECT_EQ(metadata_->SetDbCreateTime(DEVICE_B, "", 10u, true), E_OK);
383 EXPECT_TRUE(metadata_->IsTimeChange(DEVICE_B, ""));
384 RuntimeContext::GetInstance()->SetTimeChanged(false);
385 RuntimeContext::GetInstance()->StopTimeTickMonitorIfNeed();
386 }
387
388 /**
389 * @tc.name: MetadataTest010
390 * @tc.desc: Test metadata set and get ability sync mark.
391 * @tc.type: FUNC
392 * @tc.require:
393 * @tc.author: suyue
394 */
395 HWTEST_F(DistributedDBMetaDataTest, MetadataTest010, TestSize.Level0)
396 {
397 /**
398 * @tc.steps: step1. Check ability sync finish before set mark.
399 * @tc.expected: step1. Default all ability sync finish is false.
400 */
401 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
402 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
403 /**
404 * @tc.steps: step2. Set user A ability sync finish.
405 * @tc.expected: step2. user A is finish user B is not finish.
406 */
407 EXPECT_EQ(metadata_->SetAbilitySyncFinishMark(DEVICE_A, USER_A, true), E_OK);
408 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
409 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
410 /**
411 * @tc.steps: step3. Set user B ability sync finish.
412 * @tc.expected: step3. user A and user B is finish.
413 */
414 EXPECT_EQ(metadata_->SetAbilitySyncFinishMark(DEVICE_A, USER_B, true), E_OK);
415 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
416 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
417 /**
418 * @tc.steps: step4. Set user A ability sync not finish.
419 * @tc.expected: step4. user A is not finish user B is finish.
420 */
421 EXPECT_EQ(metadata_->SetAbilitySyncFinishMark(DEVICE_A, USER_A, false), E_OK);
422 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
423 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
424 /**
425 * @tc.steps: step5. Clear all time sync finish.
426 * @tc.expected: step5. user A and user B unchanged.
427 */
428 EXPECT_EQ(metadata_->ClearAllTimeSyncFinishMark(), E_OK);
429 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
430 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
431 /**
432 * @tc.steps: step6. Clear all ability sync finish.
433 * @tc.expected: step6. user A and user B is not finish.
434 */
435 EXPECT_EQ(metadata_->ClearAllAbilitySyncFinishMark(), E_OK);
436 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
437 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
438 }
439
440 /**
441 * @tc.name: MetadataTest011
442 * @tc.desc: Test metadata set and get time sync mark.
443 * @tc.type: FUNC
444 * @tc.require:
445 * @tc.author: suyue
446 */
447 HWTEST_F(DistributedDBMetaDataTest, MetadataTest011, TestSize.Level0)
448 {
449 /**
450 * @tc.steps: step1. Check time sync finish before set mark.
451 * @tc.expected: step1. Default all time sync finish is false.
452 */
453 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_A));
454 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_B));
455 /**
456 * @tc.steps: step2. Set user A time sync finish.
457 * @tc.expected: step2. user A is finish user B is not finish.
458 */
459 EXPECT_EQ(metadata_->SetTimeSyncFinishMark(DEVICE_A, USER_A, true), E_OK);
460 EXPECT_TRUE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_A));
461 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_B));
462 /**
463 * @tc.steps: step3. Set user B time sync finish.
464 * @tc.expected: step3. user A and user B is finish.
465 */
466 EXPECT_EQ(metadata_->SetTimeSyncFinishMark(DEVICE_A, USER_B, true), E_OK);
467 EXPECT_TRUE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_A));
468 EXPECT_TRUE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_B));
469 /**
470 * @tc.steps: step4. Set user A time sync not finish.
471 * @tc.expected: step4. user A is not finish user B is finish.
472 */
473 EXPECT_EQ(metadata_->SetTimeSyncFinishMark(DEVICE_A, USER_A, false), E_OK);
474 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_A));
475 EXPECT_TRUE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_B));
476 /**
477 * @tc.steps: step5. Clear all time sync finish.
478 * @tc.expected: step5. user A and user B is not finish.
479 */
480 EXPECT_EQ(metadata_->ClearAllTimeSyncFinishMark(), E_OK);
481 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_A));
482 EXPECT_FALSE(metadata_->IsTimeSyncFinish(DEVICE_A, USER_B));
483 }
484
485 /**
486 * @tc.name: MetadataTest012
487 * @tc.desc: Test metadata set remote schema version.
488 * @tc.type: FUNC
489 * @tc.require:
490 * @tc.author: suyue
491 */
492 HWTEST_F(DistributedDBMetaDataTest, MetadataTest012, TestSize.Level0)
493 {
494 /**
495 * @tc.steps: step1. Check remote schema version before set version.
496 * @tc.expected: step1. Default all version is zero.
497 */
498 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, USER_A), 0u);
499 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, USER_B), 0u);
500 /**
501 * @tc.steps: step2. Set user A schema version.
502 * @tc.expected: step2. user A is finish user B is not finish.
503 */
504 EXPECT_EQ(metadata_->SetRemoteSchemaVersion(DEVICE_A, USER_A, SOFTWARE_VERSION_CURRENT), E_OK);
505 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, USER_A), SOFTWARE_VERSION_CURRENT);
506 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, USER_B), 0u);
507 /**
508 * @tc.steps: step3. Clear all ability sync finish.
509 * @tc.expected: step3. user A and user B version is zero.
510 */
511 EXPECT_EQ(metadata_->ClearAllAbilitySyncFinishMark(), E_OK);
512 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, USER_A), 0u);
513 EXPECT_EQ(metadata_->GetRemoteSchemaVersion(DEVICE_A, USER_B), 0u);
514 }
515
516 /**
517 * @tc.name: MetadataTest013
518 * @tc.desc: Test metadata set remote system time off set.
519 * @tc.type: FUNC
520 * @tc.require:
521 * @tc.author: suyue
522 */
523 HWTEST_F(DistributedDBMetaDataTest, MetadataTest013, TestSize.Level0)
524 {
525 /**
526 * @tc.steps: step1. Check remote schema version before set version.
527 * @tc.expected: step1. Default all version is zero.
528 */
529 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, USER_A), 0u);
530 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, USER_B), 0u);
531 /**
532 * @tc.steps: step2. Set user A schema version.
533 * @tc.expected: step2. user A is finish user B is not finish.
534 */
535 const int64_t offset = 100u;
536 EXPECT_EQ(metadata_->SetSystemTimeOffset(DEVICE_A, USER_A, offset), E_OK);
537 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, USER_A), offset);
538 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, USER_B), 0u);
539 /**
540 * @tc.steps: step3. Clear all time sync finish.
541 * @tc.expected: step3. user A and user B system time offset is zero.
542 */
543 EXPECT_EQ(metadata_->ClearAllTimeSyncFinishMark(), E_OK);
544 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, USER_A), 0u);
545 EXPECT_EQ(metadata_->GetSystemTimeOffset(DEVICE_A, USER_B), 0u);
546 }
547
548 /**
549 * @tc.name: MetadataTest014
550 * @tc.desc: Test metadata remove device data with reload.
551 * @tc.type: FUNC
552 * @tc.require:
553 * @tc.author: suyue
554 */
555 HWTEST_F(DistributedDBMetaDataTest, MetadataTest014, TestSize.Level0)
556 {
557 /**
558 * @tc.steps: step1. Set storage ability sync finish.
559 * @tc.expected: step1. user A and B finish.
560 */
561 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
562 EXPECT_FALSE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
563
564 /**
565 * @tc.steps: step2. Check ability sync finish by meta.
566 * @tc.expected: step2. user A and B is finish because meta data is loaded from db.
567 */
568 std::string hashDeviceIdA = DBConstant::DEVICEID_PREFIX_KEY + DBCommon::TransferHashString(DEVICE_A) +
569 DBConstant::USERID_PREFIX_KEY + USER_A;
570 MetaDataValue metaDataValueA;
571 GetMetaDataValue(hashDeviceIdA, metaDataValueA);
572 EXPECT_EQ(metaDataValueA.syncMark & static_cast<uint64_t>(SyncMark::SYNC_MARK_ABILITY_SYNC), 0u);
573 metaDataValueA.syncMark = static_cast<uint64_t>(SyncMark::SYNC_MARK_ABILITY_SYNC);
574 PutMetaDataValue(hashDeviceIdA, metaDataValueA);
575
576 std::string hashDeviceIdB = DBConstant::DEVICEID_PREFIX_KEY + DBCommon::TransferHashString(DEVICE_A) +
577 DBConstant::USERID_PREFIX_KEY + USER_B;
578 MetaDataValue metaDataValueB;
579 GetMetaDataValue(hashDeviceIdB, metaDataValueB);
580 EXPECT_EQ(metaDataValueB.syncMark & static_cast<uint64_t>(SyncMark::SYNC_MARK_ABILITY_SYNC), 0u);
581 metaDataValueB.syncMark = static_cast<uint64_t>(SyncMark::SYNC_MARK_ABILITY_SYNC);
582 PutMetaDataValue(hashDeviceIdB, metaDataValueB);
583
584 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
585 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
586
587 /**
588 * @tc.steps: step3. Erase water mark and check again.
589 * @tc.expected: step3. user A and B is finish because meta data is loaded from db.
590 */
591 EXPECT_EQ(metadata_->EraseDeviceWaterMark(DEVICE_A, true), E_OK);
592 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_A));
593 EXPECT_TRUE(metadata_->IsAbilitySyncFinish(DEVICE_A, USER_B));
594 }
595
596 /**
597 * @tc.name: MetadataTest015
598 * @tc.desc: Test metadata init with time change if need.
599 * @tc.type: FUNC
600 * @tc.require:
601 * @tc.author: suyue
602 */
603 HWTEST_F(DistributedDBMetaDataTest, MetadataTest015, TestSize.Level0)
604 {
605 /**
606 * @tc.steps: step1. Check time sync finish by meta.
607 * @tc.expected: step1. user A and B is change because of time change.
608 */
609 RuntimeContext::GetInstance()->SetTimeChanged(true);
610 EXPECT_TRUE(metadata_->IsTimeChange(DEVICE_B, USER_A));
611 EXPECT_TRUE(metadata_->IsTimeChange(DEVICE_B, USER_B));
612 RuntimeContext::GetInstance()->SetTimeChanged(false);
613 RuntimeContext::GetInstance()->StopTimeTickMonitorIfNeed();
614 }
615
616 /**
617 * @tc.name: MetadataTest016
618 * @tc.desc: Test metaData init correctly
619 * @tc.type: FUNC
620 * @tc.require:
621 * @tc.author: suyue
622 */
623 HWTEST_F(DistributedDBMetaDataTest, MetadataTest016, TestSize.Level1)
624 {
625 /**
626 * @tc.steps: step1. init meta data
627 * @tc.expected: step1. E_OK
628 */
629 Metadata meta;
630 VirtualSingleVerSyncDBInterface storage;
631 WaterMark setWaterMark = 1;
632 ASSERT_EQ(meta.Initialize(&storage), E_OK);
633
634 /**
635 * @tc.steps: step2. meta save and get waterMark
636 * @tc.expected: step2. expect get the same waterMark
637 */
638 EXPECT_EQ(meta.SaveLocalWaterMark(DEVICE_A, USER_A, setWaterMark), E_OK);
639 EXPECT_EQ(meta.SaveLocalWaterMark(DEVICE_A, USER_B, setWaterMark), E_OK);
640 WaterMark getWaterMark = 0;
641 meta.GetLocalWaterMark(DEVICE_A, USER_A, getWaterMark);
642 EXPECT_EQ(getWaterMark, setWaterMark);
643 meta.GetLocalWaterMark(DEVICE_A, USER_B, getWaterMark);
644 EXPECT_EQ(getWaterMark, setWaterMark);
645
646 /**
647 * @tc.steps: step3. init again
648 * @tc.expected: step3. E_OK
649 */
650 Metadata anotherMeta;
651 ASSERT_EQ(anotherMeta.Initialize(&storage), E_OK);
652
653 /**
654 * @tc.steps: step4. get waterMark again
655 * @tc.expected: step4. expect get the same waterMark
656 */
657 anotherMeta.GetLocalWaterMark(DEVICE_A, USER_A, getWaterMark);
658 EXPECT_EQ(getWaterMark, setWaterMark);
659 anotherMeta.GetLocalWaterMark(DEVICE_A, USER_B, getWaterMark);
660 EXPECT_EQ(getWaterMark, setWaterMark);
661 }
662
663 /**
664 * @tc.name: MetadataTest017
665 * @tc.desc: Test metaData save and get queryWaterMark.
666 * @tc.type: FUNC
667 * @tc.require:
668 * @tc.author: suyue
669 */
670 HWTEST_F(DistributedDBMetaDataTest, MetadataTest017, TestSize.Level1)
671 {
672 /**
673 * @tc.steps: step1. save receive and send watermark
674 * @tc.expected: step1. E_OK
675 */
676 WaterMark w1 = 1;
677 EXPECT_EQ(metadata_->SetRecvQueryWaterMark("Q1", DEVICE_A, USER_A, w1), E_OK);
678 EXPECT_EQ(metadata_->SetSendQueryWaterMark("Q1", DEVICE_A, USER_A, w1), E_OK);
679 WaterMark w2 = 2;
680 EXPECT_EQ(metadata_->SetRecvQueryWaterMark("Q1", DEVICE_A, USER_B, w2), E_OK);
681 EXPECT_EQ(metadata_->SetSendQueryWaterMark("Q1", DEVICE_A, USER_B, w2), E_OK);
682 /**
683 * @tc.steps: step2. get receive and send watermark
684 * @tc.expected: step2. E_OK and get the latest value
685 */
686 WaterMark w = 0;
687 EXPECT_EQ(metadata_->GetRecvQueryWaterMark("Q1", DEVICE_A, USER_A, w), E_OK);
688 EXPECT_EQ(w1, w);
689 EXPECT_EQ(metadata_->GetSendQueryWaterMark("Q1", DEVICE_A, USER_A, w), E_OK);
690 EXPECT_EQ(w1, w);
691 EXPECT_EQ(metadata_->GetRecvQueryWaterMark("Q1", DEVICE_A, USER_B, w), E_OK);
692 EXPECT_EQ(w2, w);
693 EXPECT_EQ(metadata_->GetSendQueryWaterMark("Q1", DEVICE_A, USER_B, w), E_OK);
694 EXPECT_EQ(w2, w);
695 /**
696 * @tc.steps: step3. set peer and local watermark
697 * @tc.expected: step3. E_OK
698 */
699 WaterMark w3 = 3;
700 EXPECT_EQ(metadata_->SaveLocalWaterMark(DEVICE_A, USER_A, w3), E_OK);
701 EXPECT_EQ(metadata_->SavePeerWaterMark(DEVICE_A, USER_A, w3, true), E_OK);
702 WaterMark w4 = 4;
703 EXPECT_EQ(metadata_->SaveLocalWaterMark(DEVICE_A, USER_B, w4), E_OK);
704 EXPECT_EQ(metadata_->SavePeerWaterMark(DEVICE_A, USER_B, w4, true), E_OK);
705 /**
706 * @tc.steps: step4. get receive and send watermark
707 * @tc.expected: step4. E_OK and get the w1
708 */
709 EXPECT_EQ(metadata_->GetRecvQueryWaterMark("Q1", DEVICE_A, USER_A, w), E_OK);
710 EXPECT_EQ(w3, w);
711 EXPECT_EQ(metadata_->GetSendQueryWaterMark("Q1", DEVICE_A, USER_A, w), E_OK);
712 EXPECT_EQ(w3, w);
713 EXPECT_EQ(metadata_->GetRecvQueryWaterMark("Q1", DEVICE_A, USER_B, w), E_OK);
714 EXPECT_EQ(w4, w);
715 EXPECT_EQ(metadata_->GetSendQueryWaterMark("Q1", DEVICE_A, USER_B, w), E_OK);
716 EXPECT_EQ(w4, w);
717 /**
718 * @tc.steps: step5. set peer and local watermark
719 * @tc.expected: step5. E_OK
720 */
721 WaterMark w5 = 5;
722 EXPECT_EQ(metadata_->SaveLocalWaterMark(DEVICE_B, USER_A, w5), E_OK);
723 EXPECT_EQ(metadata_->SavePeerWaterMark(DEVICE_B, USER_A, w5, true), E_OK);
724 WaterMark w6 = 6;
725 EXPECT_EQ(metadata_->SaveLocalWaterMark(DEVICE_B, USER_B, w6), E_OK);
726 EXPECT_EQ(metadata_->SavePeerWaterMark(DEVICE_B, USER_B, w6, true), E_OK);
727 /**
728 * @tc.steps: step6. get receive and send watermark
729 * @tc.expected: step6. E_OK and get the w3
730 */
731 EXPECT_EQ(metadata_->GetRecvQueryWaterMark("Q2", DEVICE_B, USER_A, w), E_OK);
732 EXPECT_EQ(w5, w);
733 EXPECT_EQ(metadata_->GetSendQueryWaterMark("Q2", DEVICE_B, USER_A, w), E_OK);
734 EXPECT_EQ(w5, w);
735 EXPECT_EQ(metadata_->GetRecvQueryWaterMark("Q2", DEVICE_B, USER_B, w), E_OK);
736 EXPECT_EQ(w6, w);
737 EXPECT_EQ(metadata_->GetSendQueryWaterMark("Q2", DEVICE_B, USER_B, w), E_OK);
738 EXPECT_EQ(w6, w);
739 /**
740 * @tc.steps: step7. get not exit receive and send watermark
741 * @tc.expected: step7. E_OK and get the 0
742 */
743 EXPECT_EQ(metadata_->GetRecvQueryWaterMark("Q3", "D3", "U3", w), E_OK);
744 EXPECT_EQ(w, 0u);
745 EXPECT_EQ(metadata_->GetSendQueryWaterMark("Q3", "D3", "U3", w), E_OK);
746 EXPECT_EQ(w, 0u);
747 }
748
749 /**
750 * @tc.name: MetadataTest018
751 * @tc.desc: Test metaData get and set dbCreateTime.
752 * @tc.type: FUNC
753 * @tc.require:
754 * @tc.author: suyue
755 */
756 HWTEST_F(DistributedDBMetaDataTest, MetadataTest018, TestSize.Level1)
757 {
758 /**
759 * @tc.steps: step1. set dbCreateTime
760 * @tc.expected: step1. E_OK
761 */
762 EXPECT_EQ(metadata_->SetDbCreateTime(DEVICE_A, USER_A, 10u, true), E_OK);
763 EXPECT_EQ(metadata_->SetDbCreateTime(DEVICE_A, USER_B, 20u, true), E_OK);
764 /**
765 * @tc.steps: step2. check dbCreateTime
766 * @tc.expected: step2. E_OK
767 */
768 uint64_t curDbCreatTime = 0;
769 metadata_->GetDbCreateTime(DEVICE_A, USER_A, curDbCreatTime);
770 EXPECT_EQ(curDbCreatTime, 10u);
771 metadata_->GetDbCreateTime(DEVICE_A, USER_B, curDbCreatTime);
772 EXPECT_EQ(curDbCreatTime, 20u);
773 /**
774 * @tc.steps: step3. user A change dbCreateTime and check
775 * @tc.expected: step3. E_OK
776 */
777 EXPECT_EQ(metadata_->SetDbCreateTime(DEVICE_A, USER_A, 30u, true), E_OK);
778 uint64_t clearDeviceDataMark = INT_MAX;
779 metadata_->GetRemoveDataMark(DEVICE_A, USER_A, clearDeviceDataMark);
780 EXPECT_EQ(clearDeviceDataMark, 1u);
781 EXPECT_EQ(metadata_->ResetMetaDataAfterRemoveData(DEVICE_A, USER_A), E_OK);
782 metadata_->GetRemoveDataMark(DEVICE_A, USER_A, clearDeviceDataMark);
783 EXPECT_EQ(clearDeviceDataMark, 0u);
784 metadata_->GetDbCreateTime(DEVICE_A, USER_A, curDbCreatTime);
785 EXPECT_EQ(curDbCreatTime, 30u);
786
787 /**
788 * @tc.steps: step4. user B unchanged dbCreateTime and check
789 * @tc.expected: step4. E_OK
790 */
791 metadata_->GetRemoveDataMark(DEVICE_A, USER_B, clearDeviceDataMark);
792 EXPECT_EQ(clearDeviceDataMark, 0u);
793 metadata_->GetDbCreateTime(DEVICE_A, USER_B, curDbCreatTime);
794 EXPECT_EQ(curDbCreatTime, 20u);
795 }
796
797 /**
798 * @tc.name: MetadataTest019
799 * @tc.desc: Test metaData save and get deleteWaterMark.
800 * @tc.type: FUNC
801 * @tc.require:
802 * @tc.author: suyue
803 */
804 HWTEST_F(DistributedDBMetaDataTest, MetadataTest019, TestSize.Level1)
805 {
806 /**
807 * @tc.steps: step1. save receive and send watermark
808 * @tc.expected: step1. E_OK
809 */
810 WaterMark w1 = 1;
811 EXPECT_EQ(metadata_->SetRecvDeleteSyncWaterMark(DEVICE_A, USER_A, w1), E_OK);
812 EXPECT_EQ(metadata_->SetSendDeleteSyncWaterMark(DEVICE_A, USER_A, w1), E_OK);
813 WaterMark w2 = 2;
814 EXPECT_EQ(metadata_->SetRecvDeleteSyncWaterMark(DEVICE_A, USER_B, w2), E_OK);
815 EXPECT_EQ(metadata_->SetSendDeleteSyncWaterMark(DEVICE_A, USER_B, w2), E_OK);
816
817 /**
818 * @tc.steps: step2. get receive and send watermark
819 * @tc.expected: step2. E_OK and get the latest value
820 */
821 WaterMark w = 0;
822 EXPECT_EQ(metadata_->GetRecvDeleteSyncWaterMark(DEVICE_A, USER_A, w), E_OK);
823 EXPECT_EQ(w1, w);
824 EXPECT_EQ(metadata_->GetSendDeleteSyncWaterMark(DEVICE_A, USER_A, w), E_OK);
825 EXPECT_EQ(w1, w);
826 EXPECT_EQ(metadata_->GetRecvDeleteSyncWaterMark(DEVICE_A, USER_B, w), E_OK);
827 EXPECT_EQ(w2, w);
828 EXPECT_EQ(metadata_->GetSendDeleteSyncWaterMark(DEVICE_A, USER_B, w), E_OK);
829 EXPECT_EQ(w2, w);
830
831 /**
832 * @tc.steps: step3. set peer and local watermark
833 * @tc.expected: step3. E_OK
834 */
835 WaterMark w3 = 3;
836 WaterMark w4 = 4;
837 EXPECT_EQ(metadata_->SaveLocalWaterMark(DEVICE_A, USER_A, w3), E_OK);
838 EXPECT_EQ(metadata_->SavePeerWaterMark(DEVICE_A, USER_A, w4, true), E_OK);
839 WaterMark w5 = 5;
840 WaterMark w6 = 6;
841 EXPECT_EQ(metadata_->SaveLocalWaterMark(DEVICE_A, USER_B, w5), E_OK);
842 EXPECT_EQ(metadata_->SavePeerWaterMark(DEVICE_A, USER_B, w6, true), E_OK);
843
844 /**
845 * @tc.steps: step4. get receive and send watermark
846 * @tc.expected: step4. E_OK and get the w1
847 */
848 EXPECT_EQ(metadata_->GetSendDeleteSyncWaterMark(DEVICE_A, USER_A, w), E_OK);
849 EXPECT_EQ(w3, w);
850 EXPECT_EQ(metadata_->GetRecvDeleteSyncWaterMark(DEVICE_A, USER_A, w), E_OK);
851 EXPECT_EQ(w4, w);
852 EXPECT_EQ(metadata_->GetSendDeleteSyncWaterMark(DEVICE_A, USER_B, w), E_OK);
853 EXPECT_EQ(w5, w);
854 EXPECT_EQ(metadata_->GetRecvDeleteSyncWaterMark(DEVICE_A, USER_B, w), E_OK);
855 EXPECT_EQ(w6, w);
856
857 /**
858 * @tc.steps: step5. set peer and local watermark
859 * @tc.expected: step5. E_OK
860 */
861 WaterMark w7 = 7;
862 EXPECT_EQ(metadata_->SaveLocalWaterMark(DEVICE_B, USER_A, w7), E_OK);
863 EXPECT_EQ(metadata_->SavePeerWaterMark(DEVICE_B, USER_A, w7, true), E_OK);
864 WaterMark w8 = 8;
865 EXPECT_EQ(metadata_->SaveLocalWaterMark(DEVICE_B, USER_B, w8), E_OK);
866 EXPECT_EQ(metadata_->SavePeerWaterMark(DEVICE_B, USER_B, w8, true), E_OK);
867
868 /**
869 * @tc.steps: step6. get receive and send watermark
870 * @tc.expected: step6. E_OK and get the w3
871 */
872 EXPECT_EQ(metadata_->GetRecvDeleteSyncWaterMark(DEVICE_B, USER_A, w), E_OK);
873 EXPECT_EQ(w7, w);
874 EXPECT_EQ(metadata_->GetSendDeleteSyncWaterMark(DEVICE_B, USER_A, w), E_OK);
875 EXPECT_EQ(w7, w);
876 EXPECT_EQ(metadata_->GetRecvDeleteSyncWaterMark(DEVICE_B, USER_B, w), E_OK);
877 EXPECT_EQ(w8, w);
878 EXPECT_EQ(metadata_->GetSendDeleteSyncWaterMark(DEVICE_B, USER_B, w), E_OK);
879 EXPECT_EQ(w8, w);
880
881 /**
882 * @tc.steps: step7. get not exit receive and send watermark
883 * @tc.expected: step7. E_OK and get the 0
884 */
885 EXPECT_EQ(metadata_->GetRecvDeleteSyncWaterMark("D3", USER_A, w), E_OK);
886 EXPECT_EQ(w, 0u);
887 EXPECT_EQ(metadata_->GetSendDeleteSyncWaterMark("D3", USER_A, w), E_OK);
888 EXPECT_EQ(w, 0u);
889 }
890 }
891