1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "kv_general_ut.h"
17
18 namespace DistributedDB {
19 using namespace testing::ext;
20 using namespace DistributedDB;
21 using namespace DistributedDBUnitTest;
22
23 class DistributedDBKVDataStatusTest : public KVGeneralUt {
24 public:
25 void SetUp() override;
26 protected:
27 static constexpr const char *DEVICE_A = "DEVICE_A";
28 static constexpr const char *DEVICE_B = "DEVICE_B";
29 static constexpr const char *DEVICE_C = "DEVICE_C";
30 static const uint32_t INVALID_DATA_OPERATOR = 0;
31 };
32
SetUp()33 void DistributedDBKVDataStatusTest::SetUp()
34 {
35 KVGeneralUt::SetUp();
36 auto storeInfo1 = GetStoreInfo1();
37 ASSERT_EQ(BasicUnitTest::InitDelegate(storeInfo1, DEVICE_A), E_OK);
38 auto storeInfo2 = GetStoreInfo2();
39 ASSERT_EQ(BasicUnitTest::InitDelegate(storeInfo2, DEVICE_B), E_OK);
40 }
41
42 /**
43 * @tc.name: OperateDataStatus001
44 * @tc.desc: Test sync from dev1 to dev2 after operate valid data status.
45 * @tc.type: FUNC
46 * @tc.require:
47 * @tc.author: caihaoting
48 */
49 HWTEST_F(DistributedDBKVDataStatusTest, OperateDataStatus001, TestSize.Level0)
50 {
51 /**
52 * @tc.steps: step1. dev1 put (k,v) and sync to dev2
53 * @tc.expected: step1. sync should return OK and dev2 exist (k,v).
54 */
55 auto storeInfo1 = GetStoreInfo1();
56 auto storeInfo2 = GetStoreInfo2();
57 auto store1 = GetDelegate(storeInfo1);
58 ASSERT_NE(store1, nullptr);
59 auto store2 = GetDelegate(storeInfo2);
60 ASSERT_NE(store2, nullptr);
61 Value expectValue = {'v'};
62 EXPECT_EQ(store1->Put({'k'}, expectValue), OK);
63 BlockPush(storeInfo1, storeInfo2);
64 Value actualValue;
65 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
66 EXPECT_EQ(actualValue, expectValue);
67 /**
68 * @tc.steps: step2. dev1 modify deviceId and operate valid data status
69 * @tc.expected: step2. OK.
70 */
71 ASSERT_EQ(KVGeneralUt::CloseDelegate(storeInfo1), E_OK);
72 ASSERT_EQ(BasicUnitTest::InitDelegate(storeInfo1, DEVICE_C), E_OK);
73 store1 = GetDelegate(storeInfo1);
74 ASSERT_NE(store1, nullptr);
75 EXPECT_EQ(store1->OperateDataStatus(static_cast<uint32_t>(DataOperator::UPDATE_TIME) |
76 static_cast<uint32_t>(DataOperator::RESET_UPLOAD_CLOUD)), OK);
77 /**
78 * @tc.steps: step3. dev1 sync to dev2
79 * @tc.expected: step3. sync should return OK and dev2 exist (k,v).
80 */
81 BlockPush(storeInfo1, storeInfo2);
82 std::vector<Entry> entries;
83 EXPECT_EQ(KVGeneralUt::GetDeviceEntries(store2, std::string(DEVICE_C), false, entries), OK);
84 EXPECT_EQ(entries.size(), 1u); // 1 record
85 EXPECT_EQ(entries[0].value, expectValue);
86 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
87 EXPECT_EQ(actualValue, expectValue);
88 }
89
90 /**
91 * @tc.name: OperateDataStatus002
92 * @tc.desc: Test sync from dev1 to dev2 after operate invalid data status.
93 * @tc.type: FUNC
94 * @tc.require:
95 * @tc.author: caihaoting
96 */
97 HWTEST_F(DistributedDBKVDataStatusTest, OperateDataStatus002, TestSize.Level0)
98 {
99 /**
100 * @tc.steps: step1. dev1 put (k,v) and sync to dev2
101 * @tc.expected: step1. sync should return OK and dev2 exist (k,v).
102 */
103 auto storeInfo1 = GetStoreInfo1();
104 auto storeInfo2 = GetStoreInfo2();
105 auto store1 = GetDelegate(storeInfo1);
106 ASSERT_NE(store1, nullptr);
107 auto store2 = GetDelegate(storeInfo2);
108 ASSERT_NE(store2, nullptr);
109 Value expectValue = {'v'};
110 EXPECT_EQ(store1->Put({'k'}, expectValue), OK);
111 BlockPush(storeInfo1, storeInfo2);
112 Value actualValue;
113 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
114 EXPECT_EQ(actualValue, expectValue);
115 /**
116 * @tc.steps: step2. dev1 modify deviceId and operate invalid data status
117 * @tc.expected: step2. OK.
118 */
119 ASSERT_EQ(KVGeneralUt::CloseDelegate(storeInfo1), E_OK);
120 ASSERT_EQ(BasicUnitTest::InitDelegate(storeInfo1, DEVICE_C), E_OK);
121 store1 = GetDelegate(storeInfo1);
122 ASSERT_NE(store1, nullptr);
123 EXPECT_EQ(store1->OperateDataStatus(INVALID_DATA_OPERATOR), OK);
124 /**
125 * @tc.steps: step3. dev1 sync to dev2
126 * @tc.expected: step3. sync should return OK and dev2 get entries by device return NOT_FOUND.
127 */
128 BlockPush(storeInfo1, storeInfo2);
129 std::vector<Entry> entries;
130 EXPECT_EQ(KVGeneralUt::GetDeviceEntries(store2, std::string(DEVICE_C), false, entries), NOT_FOUND);
131 EXPECT_EQ(entries.size(), 0u); // 0 record
132 }
133
134 /**
135 * @tc.name: OperateDataStatus003
136 * @tc.desc: Test sync from dev1 to dev2 after operate data status RESET_UPLOAD_CLOUD.
137 * @tc.type: FUNC
138 * @tc.require:
139 * @tc.author: caihaoting
140 */
141 HWTEST_F(DistributedDBKVDataStatusTest, OperateDataStatus003, TestSize.Level0)
142 {
143 /**
144 * @tc.steps: step1. dev1 put (k,v) and sync to dev2
145 * @tc.expected: step1. sync should return OK and dev2 exist (k,v).
146 */
147 auto storeInfo1 = GetStoreInfo1();
148 auto storeInfo2 = GetStoreInfo2();
149 auto store1 = GetDelegate(storeInfo1);
150 ASSERT_NE(store1, nullptr);
151 auto store2 = GetDelegate(storeInfo2);
152 ASSERT_NE(store2, nullptr);
153 Value expectValue = {'v'};
154 EXPECT_EQ(store1->Put({'k'}, expectValue), OK);
155 BlockPush(storeInfo1, storeInfo2);
156 Value actualValue;
157 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
158 EXPECT_EQ(actualValue, expectValue);
159 /**
160 * @tc.steps: step2. dev1 modify deviceId and operate data status RESET_UPLOAD_CLOUD
161 * @tc.expected: step2. OK.
162 */
163 ASSERT_EQ(KVGeneralUt::CloseDelegate(storeInfo1), E_OK);
164 ASSERT_EQ(BasicUnitTest::InitDelegate(storeInfo1, DEVICE_C), E_OK);
165 store1 = GetDelegate(storeInfo1);
166 ASSERT_NE(store1, nullptr);
167 EXPECT_EQ(store1->OperateDataStatus(static_cast<uint32_t>(DataOperator::RESET_UPLOAD_CLOUD)), OK);
168 /**
169 * @tc.steps: step3. dev1 sync to dev2
170 * @tc.expected: step3. sync should return OK and dev2 get entries by device return NOT_FOUND.
171 */
172 BlockPush(storeInfo1, storeInfo2);
173 std::vector<Entry> entries;
174 EXPECT_EQ(KVGeneralUt::GetDeviceEntries(store2, std::string(DEVICE_C), false, entries), NOT_FOUND);
175 EXPECT_EQ(entries.size(), 0u); // 0 record
176 }
177
178 /**
179 * @tc.name: OperateDataStatus004
180 * @tc.desc: Test sync with delete data.
181 * @tc.type: FUNC
182 * @tc.require:
183 * @tc.author: zqq
184 */
185 HWTEST_F(DistributedDBKVDataStatusTest, OperateDataStatus004, TestSize.Level0)
186 {
187 /**
188 * @tc.steps: step1. dev1 put (k,v) and sync to dev2
189 * @tc.expected: step1. sync should return OK and dev2 exist (k,v).
190 */
191 auto storeInfo1 = GetStoreInfo1();
192 auto storeInfo2 = GetStoreInfo2();
193 auto store1 = GetDelegate(storeInfo1);
194 ASSERT_NE(store1, nullptr);
195 auto store2 = GetDelegate(storeInfo2);
196 ASSERT_NE(store2, nullptr);
197 Value expectValue = {'v'};
198 EXPECT_EQ(store1->Put({'k'}, expectValue), OK);
199 BlockPush(storeInfo1, storeInfo2);
200 EXPECT_EQ(store1->Delete({'k'}), OK);
201 BlockPush(storeInfo1, storeInfo2);
202 /**
203 * @tc.steps: step2. dev1 modify deviceId and operate data status RESET_UPLOAD_CLOUD
204 * @tc.expected: step2. OK.
205 */
206 ASSERT_EQ(KVGeneralUt::CloseDelegate(storeInfo1), E_OK);
207 ASSERT_EQ(BasicUnitTest::InitDelegate(storeInfo1, DEVICE_C), E_OK);
208 store1 = GetDelegate(storeInfo1);
209 ASSERT_NE(store1, nullptr);
210 EXPECT_EQ(store1->OperateDataStatus(static_cast<uint32_t>(DataOperator::RESET_UPLOAD_CLOUD)), OK);
211 /**
212 * @tc.steps: step3. dev1 sync to dev2
213 * @tc.expected: step3. sync should return OK and dev2 get entries by device return NOT_FOUND.
214 */
215 BlockPush(storeInfo1, storeInfo2);
216 std::vector<Entry> entries;
217 EXPECT_EQ(KVGeneralUt::GetDeviceEntries(store2, std::string(DEVICE_C), false, entries), NOT_FOUND);
218 EXPECT_EQ(entries.size(), 0u); // 0 record
219 }
220
221 #ifdef USE_DISTRIBUTEDDB_CLOUD
222 /**
223 * @tc.name: CloudOperateDataStatus001
224 * @tc.desc: Test sync cloud after operate valid data status.
225 * @tc.type: FUNC
226 * @tc.require:
227 * @tc.author: caihaoting
228 */
229 HWTEST_F(DistributedDBKVDataStatusTest, CloudOperateDataStatus001, TestSize.Level0)
230 {
231 /**
232 * @tc.steps: step1. dev1 put (k,v) and sync cloud and dev2 sync cloud
233 * @tc.expected: step1. sync should return OK and dev2 exist (k,v).
234 */
235 auto storeInfo1 = GetStoreInfo1();
236 auto storeInfo2 = GetStoreInfo2();
237 auto store1 = GetDelegate(storeInfo1);
238 ASSERT_NE(store1, nullptr);
239 ASSERT_EQ(SetCloud(store1), OK);
240 auto store2 = GetDelegate(storeInfo2);
241 ASSERT_NE(store2, nullptr);
242 ASSERT_EQ(SetCloud(store2), OK);
243 Value expectValue = {'v'};
244 EXPECT_EQ(store1->Put({'k'}, expectValue), OK);
245 BlockCloudSync(storeInfo1, DEVICE_A);
246 BlockCloudSync(storeInfo2, DEVICE_B);
247 Value actualValue;
248 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
249 EXPECT_EQ(actualValue, expectValue);
250 /**
251 * @tc.steps: step2. dev1 operate valid data status
252 * @tc.expected: step2. OK.
253 */
254 EXPECT_EQ(store1->OperateDataStatus(static_cast<uint32_t>(DataOperator::UPDATE_TIME) |
255 static_cast<uint32_t>(DataOperator::RESET_UPLOAD_CLOUD)), OK);
256 /**
257 * @tc.steps: step3. dev1 modify deviceId and sync cloud and dev2 sync cloud
258 * @tc.expected: step3. sync should return OK and dev2 exist (k,v).
259 */
260 BlockCloudSync(storeInfo1, DEVICE_C);
261 BlockCloudSync(storeInfo2, DEVICE_B);
262 std::vector<Entry> entries;
263 EXPECT_EQ(KVGeneralUt::GetDeviceEntries(store2, std::string(DEVICE_C), false, entries), OK);
264 EXPECT_EQ(entries.size(), 1u); // 1 record
265 EXPECT_EQ(entries[0].value, expectValue);
266 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
267 EXPECT_EQ(actualValue, expectValue);
268 }
269
270 /**
271 * @tc.name: CloudOperateDataStatus002
272 * @tc.desc: Test sync cloud after operate invalid data status.
273 * @tc.type: FUNC
274 * @tc.require:
275 * @tc.author: caihaoting
276 */
277 HWTEST_F(DistributedDBKVDataStatusTest, CloudOperateDataStatus002, TestSize.Level0)
278 {
279 /**
280 * @tc.steps: step1. dev1 put (k,v) and sync cloud and dev2 sync cloud
281 * @tc.expected: step1. sync should return OK and dev2 exist (k,v).
282 */
283 auto storeInfo1 = GetStoreInfo1();
284 auto storeInfo2 = GetStoreInfo2();
285 auto store1 = GetDelegate(storeInfo1);
286 ASSERT_NE(store1, nullptr);
287 ASSERT_EQ(SetCloud(store1), OK);
288 auto store2 = GetDelegate(storeInfo2);
289 ASSERT_NE(store2, nullptr);
290 ASSERT_EQ(SetCloud(store2), OK);
291 Value expectValue = {'v'};
292 EXPECT_EQ(store1->Put({'k'}, expectValue), OK);
293 BlockCloudSync(storeInfo1, DEVICE_A);
294 BlockCloudSync(storeInfo2, DEVICE_B);
295 Value actualValue;
296 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
297 EXPECT_EQ(actualValue, expectValue);
298 /**
299 * @tc.steps: step2. dev1 operate invalid data status
300 * @tc.expected: step2. OK.
301 */
302 EXPECT_EQ(store1->OperateDataStatus(INVALID_DATA_OPERATOR), OK);
303 /**
304 * @tc.steps: step3. dev1 modify deviceId and sync cloud and dev2 sync cloud
305 * @tc.expected: step3. sync should return OK and dev2 get entries by device return NOT_FOUND.
306 */
307 BlockCloudSync(storeInfo1, DEVICE_C);
308 BlockCloudSync(storeInfo2, DEVICE_B);
309 std::vector<Entry> entries;
310 EXPECT_EQ(KVGeneralUt::GetDeviceEntries(store2, std::string(DEVICE_C), false, entries), NOT_FOUND);
311 EXPECT_EQ(entries.size(), 0u); // 0 record
312 }
313
314 /**
315 * @tc.name: CloudOperateDataStatus003
316 * @tc.desc: Test sync cloud after operate data status RESET_UPLOAD_CLOUD.
317 * @tc.type: FUNC
318 * @tc.require:
319 * @tc.author: caihaoting
320 */
321 HWTEST_F(DistributedDBKVDataStatusTest, CloudOperateDataStatus003, TestSize.Level0)
322 {
323 /**
324 * @tc.steps: step1. dev1 put (k,v) and sync cloud and dev2 sync cloud
325 * @tc.expected: step1. sync should return OK and dev2 exist (k,v).
326 */
327 auto storeInfo1 = GetStoreInfo1();
328 auto storeInfo2 = GetStoreInfo2();
329 auto store1 = GetDelegate(storeInfo1);
330 ASSERT_NE(store1, nullptr);
331 ASSERT_EQ(SetCloud(store1), OK);
332 auto store2 = GetDelegate(storeInfo2);
333 ASSERT_NE(store2, nullptr);
334 ASSERT_EQ(SetCloud(store2), OK);
335 Value expectValue = {'v'};
336 EXPECT_EQ(store1->Put({'k'}, expectValue), OK);
337 BlockCloudSync(storeInfo1, DEVICE_A);
338 BlockCloudSync(storeInfo2, DEVICE_B);
339 Value actualValue;
340 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
341 EXPECT_EQ(actualValue, expectValue);
342 /**
343 * @tc.steps: step2. dev1 operate data status RESET_UPLOAD_CLOUD
344 * @tc.expected: step2. OK.
345 */
346 EXPECT_EQ(store1->OperateDataStatus(static_cast<uint32_t>(DataOperator::RESET_UPLOAD_CLOUD)), OK);
347 /**
348 * @tc.steps: step3. dev1 modify deviceId and sync cloud and dev2 sync cloud
349 * @tc.expected: step3. sync should return OK and dev2 exist (k,v).
350 */
351 BlockCloudSync(storeInfo1, DEVICE_C);
352 BlockCloudSync(storeInfo2, DEVICE_B);
353 std::vector<Entry> entries;
354 EXPECT_EQ(KVGeneralUt::GetDeviceEntries(store2, std::string(DEVICE_C), false, entries), OK);
355 EXPECT_EQ(entries.size(), 1u); // 1 record
356 EXPECT_EQ(entries[0].value, expectValue);
357 EXPECT_EQ(store2->Get({'k'}, actualValue), OK);
358 EXPECT_EQ(actualValue, expectValue);
359 }
360 #endif // USE_DISTRIBUTEDDB_CLOUD
361 } // namespace DistributedDB