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
16 #include "cloud_syncer_test.h"
17 #include "distributeddb_tools_unit_test.h"
18 #include "mock_icloud_sync_storage_interface.h"
19 #include "mock_iclouddb.h"
20 #include "sqlite_single_ver_relational_continue_token.h"
21 #include "store_types.h"
22 #include "types_export.h"
23
24 using namespace testing::ext;
25 using namespace testing;
26 using namespace DistributedDB;
27 using namespace DistributedDBUnitTest;
28
29 namespace {
30
31 constexpr auto TABLE_NAME_1 = "tableName1";
32 constexpr auto CLOUD_WATER_MARK = "tableName1";
33
34
CommonExpectCall(MockICloudSyncStorageInterface * iCloud)35 static void CommonExpectCall(MockICloudSyncStorageInterface *iCloud)
36 {
37 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
38 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
39 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
40 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
41 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
42 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
43 EXPECT_CALL(*iCloud, ReleaseCloudDataToken(_)).WillRepeatedly(Return(E_OK));
44 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
45 EXPECT_CALL(*iCloud, GetCloudDataNext(_, _)).WillRepeatedly(Return(E_OK));
46 EXPECT_CALL(*iCloud, GetCloudDbSchema(_)).WillRepeatedly(Return(E_OK));
47 }
BatchExpectCall(MockICloudSyncStorageInterface * iCloud)48 static void BatchExpectCall(MockICloudSyncStorageInterface *iCloud)
49 {
50 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
51 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
52 }
53 class DistributedDBCloudSyncerUploadTest : public testing::Test {
54 public:
55 static void SetUpTestCase(void);
56 static void TearDownTestCase(void);
57 void SetUp();
58 void TearDown();
59 };
60
SetUpTestCase(void)61 void DistributedDBCloudSyncerUploadTest::SetUpTestCase(void)
62 {
63 }
64
TearDownTestCase(void)65 void DistributedDBCloudSyncerUploadTest::TearDownTestCase(void)
66 {
67 }
68
SetUp(void)69 void DistributedDBCloudSyncerUploadTest::SetUp(void)
70 {
71 DistributedDBToolsUnitTest::PrintTestCaseInfo();
72 }
73
TearDown(void)74 void DistributedDBCloudSyncerUploadTest::TearDown(void)
75 {
76 }
77
78 /**
79 * @tc.name: UploadModeCheck001
80 * @tc.desc: Test different strategies of sync task call DoUpload()
81 * @tc.type: FUNC
82 * @tc.require: AR000HSNJO
83 * @tc.author: huangboxin
84 */
85 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck001, TestSize.Level1)
86 {
87 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
88 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
89 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
90 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
91 cloudSyncer->SetMockICloudDB(idb);
92 TaskId taskId = 1;
93
94 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
95 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
96 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
97 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _)).WillRepeatedly(Return(E_OK));
98 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
99 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
100 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
101 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _)).WillRepeatedly(Return(E_OK));
102
103 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_PUSH_ONLY);
104 int errCode = cloudSyncer->CallDoUpload(taskId);
105 EXPECT_EQ(errCode, -E_INVALID_ARGS);
106
107 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_PULL_ONLY);
108 errCode = cloudSyncer->CallDoUpload(taskId);
109 EXPECT_EQ(errCode, -E_INVALID_ARGS);
110
111 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_PUSH_PULL);
112 errCode = cloudSyncer->CallDoUpload(taskId);
113 EXPECT_EQ(errCode, -E_INVALID_ARGS);
114
115 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_MERGE);
116 errCode = cloudSyncer->CallDoUpload(taskId);
117 EXPECT_EQ(errCode, E_OK);
118
119 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PUSH);
120 errCode = cloudSyncer->CallDoUpload(taskId);
121 EXPECT_EQ(errCode, E_OK);
122
123 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PULL);
124 errCode = cloudSyncer->CallDoUpload(taskId);
125 EXPECT_EQ(errCode, -E_INVALID_ARGS);
126
127 errCode = cloudSyncer->CallDoUpload(taskId);
128 EXPECT_EQ(errCode, -E_INVALID_ARGS);
129 cloudSyncer->CallClose();
130 RefObject::KillAndDecObjRef(cloudSyncer);
131
132 storageProxy.reset();
133 delete iCloud;
134 idb = nullptr;
135 }
136
137 /**
138 * @tc.name: UploadModeCheck002
139 * @tc.desc: Test case1 about getting water mark
140 * @tc.type: FUNC
141 * @tc.require: AR000HSNJO
142 * @tc.author: huangboxin
143 */
144 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck002, TestSize.Level1)
145 {
146 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
147 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
148 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
149 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
150 cloudSyncer->SetMockICloudDB(idb);
151 TaskId taskId = 2u;
152
153 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
154 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _)).WillRepeatedly(Return(E_OK));
155 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
156 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
157 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
158 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _)).WillRepeatedly(Return(E_OK));
159
160 // 1. The water level was read successfully
161 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_MERGE);
162 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillOnce(Return(E_OK));
163 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
164
165 int errCode = cloudSyncer->CallDoUpload(taskId);
166 EXPECT_EQ(errCode, E_OK);
167 cloudSyncer->CallClose();
168 RefObject::KillAndDecObjRef(cloudSyncer);
169
170 storageProxy.reset();
171 delete iCloud;
172 idb = nullptr;
173 }
174 /**
175 * @tc.name: UploadModeCheck003
176 * @tc.desc: Test case2 about getting water mark
177 * @tc.type: FUNC
178 * @tc.require: AR000HSNJO
179 * @tc.author: huangboxin
180 */
181 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck003, TestSize.Level1)
182 {
183 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
184 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
185 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
186 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
187 cloudSyncer->SetMockICloudDB(idb);
188
189 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
190 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _)).WillRepeatedly(Return(E_OK));
191 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
192 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
193 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
194 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _)).WillRepeatedly(Return(E_OK));
195 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
196
197 // 2. Failed to read water level
198 TaskId taskId = 3u;
199 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_MERGE);
200 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillOnce(Return(-E_INVALID_DB));
201 int errCode = cloudSyncer->CallDoUpload(taskId);
202 EXPECT_EQ(errCode, -E_INVALID_DB);
203
204 cloudSyncer->CallClose();
205 RefObject::KillAndDecObjRef(cloudSyncer);
206 storageProxy.reset();
207 delete iCloud;
208 idb = nullptr;
209 }
210
211 /**
212 * @tc.name: UploadModeCheck004
213 * @tc.desc: Test case1 about Getting upload count
214 * @tc.type: FUNC
215 * @tc.require: AR000HSNJO
216 * @tc.author: huangboxin
217 */
218 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck004, TestSize.Level1)
219 {
220 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
221 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
222 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
223 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
224 cloudSyncer->SetMockICloudDB(idb);
225 cloudSyncer->InitCloudSyncer(3u, SYNC_MODE_CLOUD_FORCE_PUSH);
226
227 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
228 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
229 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
230 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
231 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
232
233 // 1. Failed to get total data count
234 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _)).WillOnce(Return(-E_INVALID_DB));
235 int errCode = cloudSyncer->CallDoUpload(3u);
236 EXPECT_EQ(errCode, -E_INVALID_DB);
237
238 RuntimeContext::GetInstance()->StopTaskPool();
239 cloudSyncer->CallClose();
240 RefObject::KillAndDecObjRef(cloudSyncer);
241 storageProxy.reset();
242 delete iCloud;
243 idb = nullptr;
244 }
245
246 /**
247 * @tc.name: UploadModeCheck005
248 * @tc.desc: Test case2 about Getting upload count
249 * @tc.type: FUNC
250 * @tc.require: AR000HSNJO
251 * @tc.author: huangboxin
252 */
253 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck005, TestSize.Level1)
254 {
255 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
256 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
257 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
258 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
259 cloudSyncer->SetMockICloudDB(idb);
260 cloudSyncer->InitCloudSyncer(3u, SYNC_MODE_CLOUD_FORCE_PUSH);
261
262 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
263 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
264 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
265 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
266 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
267 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
268 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _)).WillRepeatedly(Return(E_OK));
269
270 // 2. get total upload count ok
271 cloudSyncer->InitCloudSyncer(10u, SYNC_MODE_CLOUD_FORCE_PUSH);
272 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _)).WillOnce(Return(E_OK));
273 int errCode = cloudSyncer->CallDoUpload(10u);
274 EXPECT_EQ(errCode, E_OK);
275
276 // 3. get total upload count ok, which is 0
277 cloudSyncer->InitCloudSyncer(11u, SYNC_MODE_CLOUD_FORCE_PUSH);
278 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43020202(const std::string &, const Timestamp &, const bool, int64_t & count) 279 .WillOnce([](const std::string &, const Timestamp &, const bool, int64_t & count) {
280 count = 0;
281 return E_OK;
282 });
283
284 errCode = cloudSyncer->CallDoUpload(11u);
285 EXPECT_EQ(errCode, E_OK);
286
287 RuntimeContext::GetInstance()->StopTaskPool();
288 cloudSyncer->CallClose();
289 RefObject::KillAndDecObjRef(cloudSyncer);
290 storageProxy.reset();
291 delete iCloud;
292 idb = nullptr;
293 }
294
295 /**
296 * @tc.name: UploadModeCheck006
297 * @tc.desc: Test case1 about CloudSyncData
298 * @tc.type: FUNC
299 * @tc.require: AR000HSNJO
300 * @tc.author: huangboxin
301 */
302 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck006, TestSize.Level1)
303 {
304 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
305 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
306 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
307 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
308 cloudSyncer->SetMockICloudDB(idb);
309 TaskId taskId = 4u;
310 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PUSH);
311
312 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
313
314 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
315 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
316 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
317 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
318 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
319 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
320 EXPECT_CALL(*iCloud, ReleaseCloudDataToken(_)).WillRepeatedly(Return(E_OK));
321 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43020302(const std::string &, const Timestamp &, const bool, int64_t & count) 322 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
323 count = 1000;
324 return E_OK;
325 });
326 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
327 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
328
329 VBucket tmp = {pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1)};
330 CloudSyncData uploadData(cloudSyncer->GetCurrentContextTableName());
331
332 // batch_1 CloudSyncData quantity > total count
333 uploadData.insData.record = std::vector<VBucket>(1001, tmp);
334 uploadData.insData.extend = std::vector<VBucket>(1001, tmp);
335 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _)).WillOnce(
__anon1a8a43020402(const TableSchema &, const Timestamp &, ContinueToken &, CloudSyncData &cloudDataResult) 336 [&uploadData](const TableSchema &, const Timestamp &, ContinueToken &, CloudSyncData &cloudDataResult) {
337 cloudDataResult = uploadData;
338 return E_OK;
339 });
340 int errCode = cloudSyncer->CallDoUpload(taskId);
341 EXPECT_EQ(errCode, -E_INTERNAL_ERROR);
342
343 RuntimeContext::GetInstance()->StopTaskPool();
344 cloudSyncer->CallClose();
345 RefObject::KillAndDecObjRef(cloudSyncer);
346 storageProxy.reset();
347 delete iCloud;
348 idb = nullptr;
349 }
350
351 /**
352 * @tc.name: UploadModeCheck007
353 * @tc.desc: Test case2 about CloudSyncData
354 * @tc.type: FUNC
355 * @tc.require: AR000HSNJO
356 * @tc.author: huangboxin
357 */
358 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck007, TestSize.Level1)
359 {
360 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
361 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
362 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
363 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
364 cloudSyncer->SetMockICloudDB(idb);
365 cloudSyncer->InitCloudSyncer(4u, SYNC_MODE_CLOUD_FORCE_PUSH);
366
367 CommonExpectCall(iCloud);
368 BatchExpectCall(iCloud);
369 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
370 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43020502(const std::string &, const Timestamp &, const bool, int64_t & count) 371 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
372 count = 1000;
373 return E_OK;
374 });
375
376 // Batch_n CloudSyncData quantity > total count
377 cloudSyncer->InitCloudSyncer(5u, SYNC_MODE_CLOUD_FORCE_PUSH);
378 CloudSyncData uploadData2(cloudSyncer->GetCurrentContextTableName());
379 VBucket tmp = { pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1),
380 pair<std::string, int64_t>(CloudDbConstant::CREATE_FIELD, 1) };
381 uploadData2.insData.record = std::vector<VBucket>(1000, tmp);
382 uploadData2.insData.extend = std::vector<VBucket>(1000, tmp);
383
384 SyncTimeRange syncTimeRange = { .beginTime = 1u };
385 QueryObject queryObject(Query::Select());
386 queryObject.SetTableName(cloudSyncer->GetCurrentContextTableName());
387 auto token = new (std::nothrow) SQLiteSingleVerRelationalContinueToken(syncTimeRange, queryObject);
388 ContinueToken conStmtToken = static_cast<ContinueToken>(token);
389 delete token;
390 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _)).WillOnce([&conStmtToken, &uploadData2](
__anon1a8a43020602( const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 391 const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
392 continueStmtToken = conStmtToken;
393 cloudDataResult = uploadData2;
394 return -E_UNFINISHED;
395 });
396
397 CloudSyncData uploadData3(cloudSyncer->GetCurrentContextTableName());
398 uploadData3.insData.record = std::vector<VBucket>(1001, tmp);
399 uploadData3.insData.extend = std::vector<VBucket>(1001, tmp);
400 EXPECT_CALL(*iCloud, GetCloudDataNext(_, _)).WillOnce(
__anon1a8a43020702(ContinueToken &, CloudSyncData &cloudDataResult) 401 [&uploadData3](ContinueToken &, CloudSyncData &cloudDataResult) {
402 cloudDataResult = uploadData3;
403 return E_OK;
404 });
405 int errCode = cloudSyncer->CallDoUpload(5u);
406 EXPECT_EQ(errCode, -E_INTERNAL_ERROR);
407
408 RuntimeContext::GetInstance()->StopTaskPool();
409 cloudSyncer->CallClose();
410 RefObject::KillAndDecObjRef(cloudSyncer);
411 storageProxy.reset();
412 delete iCloud;
413 idb = nullptr;
414 }
415
416 /**
417 * @tc.name: UploadModeCheck008
418 * @tc.desc: Test case3 about CloudSyncData
419 * @tc.type: FUNC
420 * @tc.require: AR000HSNJO
421 * @tc.author: huangboxin
422 */
423 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck008, TestSize.Level1)
424 {
425 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
426 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
427 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
428 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
429 cloudSyncer->SetMockICloudDB(idb);
430 TaskId taskId = 4u;
431 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PUSH);
432
433 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
434
435 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
436 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
437 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
438 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
439 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
440 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
441 EXPECT_CALL(*iCloud, ReleaseCloudDataToken(_)).WillRepeatedly(Return(E_OK));
442 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43020802(const std::string &, const Timestamp &, const bool, int64_t & count) 443 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
444 count = 1000;
445 return E_OK;
446 });
447 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
448 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
449
450 // empty CloudSyncData
451
452 taskId = 6u;
453 CloudSyncData uploadData2(cloudSyncer->GetCurrentContextTableName());
454 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PUSH);
455 uploadData2.insData.record = std::vector<VBucket>(100);
456 uploadData2.insData.extend = std::vector<VBucket>(100);
457 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
458 .WillOnce([&uploadData2](const TableSchema &, const Timestamp &,
__anon1a8a43020902(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 459 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
460 cloudDataResult = uploadData2;
461 return -E_UNFINISHED;
462 });
463
464 int errCode = cloudSyncer->CallDoUpload(taskId);
465 EXPECT_EQ(errCode, -E_INTERNAL_ERROR);
466
467 RuntimeContext::GetInstance()->StopTaskPool();
468 cloudSyncer->CallClose();
469 RefObject::KillAndDecObjRef(cloudSyncer);
470 storageProxy.reset();
471 delete iCloud;
472 idb = nullptr;
473 }
474
475 /**
476 * @tc.name: UploadModeCheck009
477 * @tc.desc: Test case about CloudSyncData
478 * @tc.type: FUNC
479 * @tc.require: AR000HSNJO
480 * @tc.author: huangboxin
481 */
482 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck009, TestSize.Level1)
483 {
484 // ClouSyncData format is ok
485 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
486 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
487 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
488 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
489 cloudSyncer->SetMockICloudDB(idb);
490
491 TaskId taskId = 5u;
492 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PUSH);
493 VBucket tmp = { pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1),
494 pair<std::string, int64_t>(CloudDbConstant::CREATE_FIELD, 1) };
495 CommonExpectCall(iCloud);
496 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
497 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
498 EXPECT_CALL(*idb, BatchDelete(_, _)).WillRepeatedly(Return(OK));
499 EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillRepeatedly(Return(OK));
500 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
501 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43020a02(const std::string &, const Timestamp &, const bool, int64_t & count) 502 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
503 count = 10000;
504 return E_OK;
505 });
506
507 CloudSyncData uploadData(cloudSyncer->GetCurrentContextTableName());
508 uploadData.insData.record = std::vector<VBucket>(1000, tmp);
509 uploadData.insData.extend = std::vector<VBucket>(1000, tmp);
510 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
511 .WillOnce([&uploadData](const TableSchema &, const Timestamp &,
__anon1a8a43020b02(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 512 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
513 cloudDataResult = uploadData;
514 return E_OK;
515 });
516 int errCode = cloudSyncer->CallDoUpload(taskId);
517 EXPECT_EQ(errCode, E_OK);
518
519 // CloudSyncData format error: record does not match extend length
520 cloudSyncer->CallClearCloudSyncData(uploadData);
521 uploadData.insData.record = std::vector<VBucket>(1000, tmp);
522 uploadData.insData.extend = std::vector<VBucket>(999, tmp);
523 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
524 .WillOnce([&uploadData](const TableSchema &, const Timestamp &,
__anon1a8a43020c02(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 525 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
526 cloudDataResult = uploadData;
527 return E_OK;
528 });
529 errCode = cloudSyncer->CallDoUpload(taskId);
530 EXPECT_EQ(errCode, -E_INTERNAL_ERROR);
531
532 RuntimeContext::GetInstance()->StopTaskPool();
533 cloudSyncer->CallClose();
534 RefObject::KillAndDecObjRef(cloudSyncer);
535 storageProxy.reset();
536 delete iCloud;
537 idb = nullptr;
538 }
539
540 /**
541 * @tc.name: UploadModeCheck017
542 * @tc.desc: Test case about CloudSyncData
543 * @tc.type: FUNC
544 * @tc.require: AR000HSNJO
545 * @tc.author: huangboxin
546 */
547 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck017, TestSize.Level1)
548 {
549 // ClouSyncData format is ok
550 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
551 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
552 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
553 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
554 cloudSyncer->SetMockICloudDB(idb);
555
556 TaskId taskId = 5u;
557 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PUSH);
558 VBucket tmp = {pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1)};
559 CommonExpectCall(iCloud);
560 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
561 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
562 EXPECT_CALL(*idb, BatchDelete(_, _)).WillRepeatedly(Return(OK));
563 EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillRepeatedly(Return(OK));
564 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
565 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43020d02(const std::string &, const Timestamp &, const bool, int64_t & count) 566 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
567 count = 10000;
568 return E_OK;
569 });
570
571 // CloudSyncData format error: tableName is different from the table name corresponding to Task
572 CloudSyncData uploadData2(cloudSyncer->GetCurrentContextTableName() + "abc");
573 uploadData2.insData.record = std::vector<VBucket>(1000, tmp);
574 uploadData2.insData.extend = std::vector<VBucket>(1000, tmp);
575 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
576 .WillOnce([&uploadData2](const TableSchema &, const Timestamp &,
__anon1a8a43020e02(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 577 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
578 cloudDataResult = uploadData2;
579 return E_OK;
580 });
581 int errCode = cloudSyncer->CallDoUpload(taskId);
582 EXPECT_EQ(errCode, -E_INTERNAL_ERROR);
583
584 RuntimeContext::GetInstance()->StopTaskPool();
585 cloudSyncer->CallClose();
586 RefObject::KillAndDecObjRef(cloudSyncer);
587 storageProxy.reset();
588 delete iCloud;
589 idb = nullptr;
590 }
591 /**
592 * @tc.name: UploadModeCheck010
593 * @tc.desc: Test case1 about batch api in upload
594 * @tc.type: FUNC
595 * @tc.require: AR000HSNJO
596 * @tc.author: huangboxin
597 */
598 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck010, TestSize.Level1)
599 {
600 // insert has data, update has data, delete has data (check whether it is running normally and info count)
601 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
602 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
603 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
604 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
605 cloudSyncer->SetMockICloudDB(idb);
606
607 TaskId taskId = 6u;
608 cloudSyncer->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PUSH);
609 CloudSyncData uploadData(cloudSyncer->GetCurrentContextTableName());
610 cloudSyncer->initFullCloudSyncData(uploadData, 1000);
611
612 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
613 .WillOnce([&uploadData](const TableSchema &, const Timestamp &,
__anon1a8a43020f02(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 614 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
615 cloudDataResult = uploadData;
616 return E_OK;
617 });
618 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
619 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
620 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
621 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43021002(const std::string &, const Timestamp &, const bool, int64_t & count) 622 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
623 count = 3000;
624 return E_OK;
625 });
626 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
627 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
628 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
629 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
630 EXPECT_CALL(*idb, BatchDelete(_, _)).WillRepeatedly(Return(OK));
631 EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillRepeatedly(Return(OK));
632 EXPECT_CALL(*iCloud, GetCloudDataNext(_, _)).WillRepeatedly(Return(E_OK));
633 EXPECT_CALL(*iCloud, GetCloudDbSchema(_)).WillRepeatedly(Return(E_OK));
634 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
635 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
636
637 int errCode = cloudSyncer->CallDoUpload(taskId);
638 EXPECT_EQ(errCode, E_OK);
639 std::this_thread::sleep_for(std::chrono::seconds(1));
640 EXPECT_EQ(cloudSyncer->GetUploadSuccessCount(taskId), 3000);
641 EXPECT_EQ(cloudSyncer->GetUploadFailCount(taskId), 0);
642
643 RuntimeContext::GetInstance()->StopTaskPool();
644 cloudSyncer->CallClose();
645 RefObject::KillAndDecObjRef(cloudSyncer);
646 storageProxy.reset();
647 delete iCloud;
648 idb = nullptr;
649 }
650
651 /**
652 * @tc.name: UploadModeCheck011
653 * @tc.desc: Test case2 about batch api in upload
654 * @tc.type: FUNC
655 * @tc.require: AR000HSNJO
656 * @tc.author: huangboxin
657 */
658 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck011, TestSize.Level1)
659 {
660 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
661 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
662 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
663 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
664 cloudSyncer->SetMockICloudDB(idb);
665 VBucket tmp = { pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1),
666 pair<std::string, int64_t>(CloudDbConstant::CREATE_FIELD, 1) };
667 cloudSyncer->InitCloudSyncer(6u, SYNC_MODE_CLOUD_FORCE_PUSH);
668
669 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
670 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
671 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
672 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43021102(const std::string &, const Timestamp &, const bool, int64_t & count) 673 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
674 count = 3000;
675 return E_OK;
676 });
677 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
678 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
679 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
680 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
681 EXPECT_CALL(*idb, BatchDelete(_, _)).WillRepeatedly(Return(OK));
682 EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillRepeatedly(Return(OK));
683 EXPECT_CALL(*iCloud, GetCloudDataNext(_, _)).WillRepeatedly(Return(E_OK));
684 EXPECT_CALL(*iCloud, GetCloudDbSchema(_)).WillRepeatedly(Return(E_OK));
685 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
686 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
687
688 // insert has no data, update and delete have data
689 CloudSyncData uploadData2(cloudSyncer->GetCurrentContextTableName());
690 uploadData2.updData.record = std::vector<VBucket>(1000, tmp);
691 uploadData2.updData.extend = std::vector<VBucket>(1000, tmp);
692 uploadData2.delData.record = std::vector<VBucket>(1000, tmp);
693 uploadData2.delData.extend = std::vector<VBucket>(1000, tmp);
694 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
695 .WillOnce([&uploadData2](const TableSchema &, const Timestamp &,
__anon1a8a43021202(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 696 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
697 cloudDataResult = uploadData2;
698 return E_OK;
699 });
700 int errCode = cloudSyncer->CallDoUpload(6u);
701 std::this_thread::sleep_for(std::chrono::seconds(1));
702 EXPECT_EQ(errCode, E_OK);
703 EXPECT_EQ(cloudSyncer->GetUploadSuccessCount(6u), 2000);
704 EXPECT_EQ(cloudSyncer->GetUploadFailCount(6u), 0);
705
706 RuntimeContext::GetInstance()->StopTaskPool();
707 cloudSyncer->CallClose();
708 RefObject::KillAndDecObjRef(cloudSyncer);
709 storageProxy.reset();
710 delete iCloud;
711 idb = nullptr;
712 }
713
714 /**
715 * @tc.name: UploadModeCheck012
716 * @tc.desc: Test case2 about batch api in upload
717 * @tc.type: FUNC
718 * @tc.require: AR000HSNJO
719 * @tc.author: huangboxin
720 */
721 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck012, TestSize.Level1)
722 {
723 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
724 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
725 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
726 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
727 cloudSyncer->SetMockICloudDB(idb);
728 VBucket tmp = { pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1),
729 pair<std::string, int64_t>(CloudDbConstant::CREATE_FIELD, 1) };
730 cloudSyncer->InitCloudSyncer(6u, SYNC_MODE_CLOUD_FORCE_PUSH);
731
732 EXPECT_CALL(*iCloud, StartTransaction(_)).WillRepeatedly(Return(E_OK));
733 EXPECT_CALL(*iCloud, ChkSchema(_)).WillRepeatedly(Return(E_OK));
734 EXPECT_CALL(*iCloud, GetMetaData(_, _)).WillRepeatedly(Return(E_OK));
735 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43021302(const std::string &, const Timestamp &, const bool, int64_t & count) 736 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
737 count = 3000;
738 return E_OK;
739 });
740 EXPECT_CALL(*iCloud, Commit()).WillRepeatedly(Return(E_OK));
741 EXPECT_CALL(*iCloud, Rollback()).WillRepeatedly(Return(E_OK));
742 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
743 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
744 EXPECT_CALL(*idb, BatchDelete(_, _)).WillRepeatedly(Return(OK));
745 EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillRepeatedly(Return(OK));
746 EXPECT_CALL(*iCloud, GetCloudDataNext(_, _)).WillRepeatedly(Return(E_OK));
747 EXPECT_CALL(*iCloud, GetCloudDbSchema(_)).WillRepeatedly(Return(E_OK));
748 EXPECT_CALL(*iCloud, GetCloudTableSchema(_, _)).WillRepeatedly(Return(E_OK));
749 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
750
751 // insert has data, update has no data, delete has data
752 CloudSyncData uploadData3(cloudSyncer->GetCurrentContextTableName());
753 uploadData3.insData.record = std::vector<VBucket>(1000, tmp);
754 uploadData3.insData.extend = std::vector<VBucket>(1000, tmp);
755 uploadData3.delData.record = std::vector<VBucket>(1000, tmp);
756 uploadData3.delData.extend = std::vector<VBucket>(1000, tmp);
757 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
758 .WillOnce([&uploadData3](const TableSchema &, const Timestamp &,
__anon1a8a43021402(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 759 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
760 cloudDataResult = uploadData3;
761 return E_OK;
762 });
763 int errCode = cloudSyncer->CallDoUpload(6u);
764 std::this_thread::sleep_for(std::chrono::seconds(1));
765 EXPECT_EQ(errCode, E_OK);
766 EXPECT_EQ(cloudSyncer->GetUploadSuccessCount(6u), 2000);
767 EXPECT_EQ(cloudSyncer->GetUploadFailCount(6u), 0);
768
769 RuntimeContext::GetInstance()->StopTaskPool();
770 cloudSyncer->CallClose();
771 RefObject::KillAndDecObjRef(cloudSyncer);
772 storageProxy.reset();
773 delete iCloud;
774 idb = nullptr;
775 }
776
777 /**
778 * @tc.name: UploadModeCheck013
779 * @tc.desc: Test case1 about upload when batch api are partially successful.
780 * @tc.type: FUNC
781 * @tc.require: AR000HSNJO
782 * @tc.author: huangboxin
783 */
784 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck013, TestSize.Level1)
785 {
786 // batch api all success.
787 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
788 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
789 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
790 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
791 cloudSyncer->SetMockICloudDB(idb);
792 cloudSyncer->InitCloudSyncer(7u, SYNC_MODE_CLOUD_FORCE_PUSH); // taskId is 7u
793
794 CommonExpectCall(iCloud);
795 BatchExpectCall(iCloud);
796
797 CloudSyncData uploadData(cloudSyncer->GetCurrentContextTableName());
798 cloudSyncer->initFullCloudSyncData(uploadData, 1000);
799 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
800 .WillRepeatedly([&uploadData](const TableSchema &, const Timestamp &,
__anon1a8a43021502(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 801 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
802 cloudDataResult = uploadData;
803 return E_OK;
804 });
805 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43021602(const std::string &, const Timestamp &, const bool, int64_t & count) 806 .WillOnce([](const std::string &, const Timestamp &, const bool, int64_t & count) {
807 count = 3000;
808 return E_OK;
809 });
810 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillOnce([&uploadData](const std::string &, std::vector<VBucket> &&record,
__anon1a8a43021702(const std::string &, std::vector<VBucket> &&record, std::vector<VBucket> &extend) 811 std::vector<VBucket> &extend) {
812 record = uploadData.insData.record;
813 extend = uploadData.insData.extend;
814 return OK;
815 });
816 EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillOnce([&uploadData](const std::string &, std::vector<VBucket> &&record,
__anon1a8a43021802(const std::string &, std::vector<VBucket> &&record, std::vector<VBucket> &extend) 817 std::vector<VBucket> &extend) {
818 record = uploadData.updData.record;
819 extend = uploadData.updData.extend;
820 return OK;
821 });
__anon1a8a43021902(const std::string &, std::vector<VBucket> &extend) 822 EXPECT_CALL(*idb, BatchDelete(_, _)).WillOnce([&uploadData](const std::string &, std::vector<VBucket> &extend) {
823 extend = uploadData.delData.extend;
824 return OK;
825 });
826 int errCode = cloudSyncer->CallDoUpload(7u); // taskId is 7u
827 EXPECT_EQ(errCode, E_OK);
828 cloudSyncer->CallNotify();
829 std::this_thread::sleep_for(std::chrono::seconds(1));
830 EXPECT_EQ(cloudSyncer->GetUploadSuccessCount(7u), 3000); // taskId is 7u
831 EXPECT_EQ(cloudSyncer->GetUploadFailCount(7u), 0); // taskId is 7u
832
833 cloudSyncer->CallClose();
834 RefObject::KillAndDecObjRef(cloudSyncer);
835 RuntimeContext::GetInstance()->StopTaskPool();
836 storageProxy.reset();
837 delete iCloud;
838 }
839
840 /**
841 * @tc.name: UploadModeCheck014
842 * @tc.desc: Test case2 about upload when batch api are partially successful.
843 * @tc.type: FUNC
844 * @tc.require: AR000HSNJO
845 * @tc.author: huangboxin
846 */
847 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck014, TestSize.Level1)
848 {
849 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
850 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
851 TestCloudSyncer *cloudSyncer2 = new(std::nothrow) TestCloudSyncer(storageProxy);
852 std::shared_ptr<MockICloudDB> idb2 = std::make_shared<MockICloudDB>();
853 cloudSyncer2->SetMockICloudDB(idb2);
854 TaskId taskId = 8u;
855
856 CommonExpectCall(iCloud);
857 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
858 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
859
860 // batch api partially success
861 cloudSyncer2->InitCloudSyncer(taskId, SYNC_MODE_CLOUD_FORCE_PUSH);
862 CloudSyncData uploadData2(cloudSyncer2->GetCurrentContextTableName());
863 cloudSyncer2->initFullCloudSyncData(uploadData2, 1000);
864 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _)).WillRepeatedly(
__anon1a8a43021a02(const TableSchema &, const Timestamp &, ContinueToken &, CloudSyncData &cloudDataResult) 865 [&uploadData2](const TableSchema &, const Timestamp &, ContinueToken &, CloudSyncData &cloudDataResult) {
866 cloudDataResult = uploadData2; return E_OK;
867 });
868 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43021b02(const std::string &, const Timestamp &, const bool, int64_t & count) 869 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
870 count = 3000;
871 return E_OK;
872 });
873 EXPECT_CALL(*idb2, BatchDelete(_, _)).WillOnce([&uploadData2](const std::string &,
__anon1a8a43021c02(const std::string &, std::vector<VBucket> &extend) 874 std::vector<VBucket> &extend) {
875 extend = uploadData2.insData.extend;
876 return OK;
877 });
878 EXPECT_CALL(*idb2, BatchInsert(_, _, _)).WillOnce([&uploadData2](const std::string &,
__anon1a8a43021d02(const std::string &, std::vector<VBucket> &&record, std::vector<VBucket> &extend) 879 std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
880 record = uploadData2.updData.record;
881 extend = uploadData2.updData.extend;
882 return DB_ERROR;
883 });
884 int errCode = cloudSyncer2->CallDoUpload(taskId);
885 EXPECT_EQ(errCode, -E_CLOUD_ERROR);
886 cloudSyncer2->CallNotify();
887 std::this_thread::sleep_for(std::chrono::seconds(1));
888 EXPECT_EQ(cloudSyncer2->GetUploadSuccessCount(taskId), 1000);
889 EXPECT_EQ(cloudSyncer2->GetUploadFailCount(taskId), 2000);
890
891 RuntimeContext::GetInstance()->StopTaskPool();
892 cloudSyncer2->CallClose();
893 RefObject::KillAndDecObjRef(cloudSyncer2);
894 storageProxy.reset();
895 delete iCloud;
896 idb2 = nullptr;
897 }
898
899 /**
900 * @tc.name: UploadModeCheck015
901 * @tc.desc: Test case3 about upload when batch api are partially successful.
902 * @tc.type: FUNC
903 * @tc.require: AR000HSNJO
904 * @tc.author: huangboxin
905 */
906 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck015, TestSize.Level1)
907 {
908 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
909 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
910 TestCloudSyncer *cloudSyncer3 = new(std::nothrow) TestCloudSyncer(storageProxy);
911 std::shared_ptr<MockICloudDB> idb3 = std::make_shared<MockICloudDB>();
912 cloudSyncer3->SetMockICloudDB(idb3);
913
914 CommonExpectCall(iCloud);
915 BatchExpectCall(iCloud);
916
917 // BatchInsert failed, BatchUpdate ok, BatchDelete ok
918 cloudSyncer3->InitCloudSyncer(9u, SYNC_MODE_CLOUD_FORCE_PUSH);
919 CloudSyncData uploadData3(cloudSyncer3->GetCurrentContextTableName());
920 cloudSyncer3->initFullCloudSyncData(uploadData3, 1000);
921 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
922 .WillRepeatedly([&uploadData3](const TableSchema &, const Timestamp &, ContinueToken &,
__anon1a8a43021e02(const TableSchema &, const Timestamp &, ContinueToken &, CloudSyncData &cloudDataResult) 923 CloudSyncData &cloudDataResult) {
924 cloudDataResult = uploadData3;
925 return E_OK;
926 });
927 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43021f02(const std::string &, const Timestamp &, const bool, int64_t & count) 928 .WillOnce([](const std::string &, const Timestamp &, const bool, int64_t & count) {
929 count = 3000;
930 return E_OK;
931 });
932 EXPECT_CALL(*idb3, BatchDelete(_, _)).WillRepeatedly([&uploadData3](const std::string &,
__anon1a8a43022002(const std::string &, std::vector<VBucket> &extend) 933 std::vector<VBucket> &extend) {
934 extend = uploadData3.insData.extend;
935 return DB_ERROR;
936 });
937 EXPECT_CALL(*idb3, BatchInsert(_, _, _)).WillRepeatedly([&uploadData3](const std::string &,
__anon1a8a43022102(const std::string &, std::vector<VBucket> &&record, std::vector<VBucket> &extend) 938 std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
939 record = uploadData3.updData.record;
940 extend = uploadData3.updData.extend;
941 return OK;
942 });
943 EXPECT_CALL(*idb3, BatchUpdate(_, _, _)).WillRepeatedly([&uploadData3](const std::string &,
__anon1a8a43022202(const std::string &, std::vector<VBucket> &&record, std::vector<VBucket> &extend) 944 std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
945 record = uploadData3.updData.record;
946 extend = uploadData3.delData.extend;
947 return OK;
948 });
949 EXPECT_EQ(cloudSyncer3->CallDoUpload(9u), -E_CLOUD_ERROR);
950 cloudSyncer3->CallNotify();
951
952 RuntimeContext::GetInstance()->StopTaskPool();
953
954 EXPECT_EQ(cloudSyncer3->GetUploadSuccessCount(9u), 0);
955 EXPECT_EQ(cloudSyncer3->GetUploadFailCount(9u), 3000);
956 cloudSyncer3->CallClose();
957 RefObject::KillAndDecObjRef(cloudSyncer3);
958 storageProxy.reset();
959 delete iCloud;
960 idb3 = nullptr;
961 }
962
ExpectCallForTestCase016(std::shared_ptr<MockICloudDB> idb,CloudSyncData & uploadData)963 static void ExpectCallForTestCase016(std::shared_ptr<MockICloudDB> idb, CloudSyncData &uploadData)
964 {
965 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly([&uploadData](const std::string &,
966 std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
967 record = uploadData.insData.record;
968 extend = uploadData.insData.extend;
969 return OK;
970 });
971 EXPECT_CALL(*idb, BatchUpdate(_, _, _)).WillRepeatedly([&uploadData](const std::string &,
972 std::vector<VBucket> &&record, std::vector<VBucket> &extend) {
973 record = uploadData.updData.record;
974 extend = uploadData.updData.extend;
975 return OK;
976 });
977 EXPECT_CALL(*idb, BatchDelete(_, _)).WillRepeatedly([&uploadData](const std::string &,
978 std::vector<VBucket> &extend) {
979 extend = uploadData.delData.extend;
980 return OK;
981 });
982 }
983
984 /**
985 * @tc.name: UploadModeCheck016
986 * @tc.desc: Test case about water level in upload
987 * @tc.type: FUNC
988 * @tc.require: AR000HSNJO
989 * @tc.author: huangboxin
990 */
991 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck016, TestSize.Level1)
992 {
993 // update water level successful
994 MockICloudSyncStorageInterface *iCloud = new MockICloudSyncStorageInterface();
995 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
996 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
997 std::shared_ptr<MockICloudDB> idb = std::make_shared<MockICloudDB>();
998 cloudSyncer->SetMockICloudDB(idb);
999 cloudSyncer->InitCloudSyncer(8u, SYNC_MODE_CLOUD_MERGE);
1000 cloudSyncer->SetCloudWaterMarks(TABLE_NAME_1, CLOUD_WATER_MARK);
1001
1002 CommonExpectCall(iCloud);
1003 // CheckSchema
1004 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
__anon1a8a43022602(const std::string &, const Timestamp &, const bool, int64_t & count) 1005 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
1006 count = 3000;
1007 return E_OK;
1008 });
1009 VBucket tmp = {pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1)};
1010 CloudSyncData uploadData(cloudSyncer->GetCurrentContextTableName());
1011 cloudSyncer->initFullCloudSyncData(uploadData, 1000);
1012
1013 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
1014 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _))
1015 .WillRepeatedly([&uploadData](const TableSchema &, const Timestamp &,
__anon1a8a43022702(const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 1016 ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
1017 cloudDataResult = uploadData;
1018 return E_OK;
1019 });
1020 ExpectCallForTestCase016(idb, uploadData);
1021 EXPECT_EQ(cloudSyncer->CallDoUpload(8u), E_OK);
1022 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillOnce(Return(-E_INVALID_DB));
1023 EXPECT_EQ(cloudSyncer->CallDoUpload(8u), -E_INVALID_DB);
1024
1025 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillOnce(Return(-E_INVALID_ARGS));
1026 EXPECT_EQ(cloudSyncer->CallDoUpload(8u), -E_INVALID_ARGS);
1027 RuntimeContext::GetInstance()->StopTaskPool();
1028 cloudSyncer->CallClose();
1029 RefObject::KillAndDecObjRef(cloudSyncer);
1030 storageProxy.reset();
1031 delete iCloud;
1032 idb = nullptr;
1033 }
1034
MockCall(MockICloudSyncStorageInterface * iCloud,const std::shared_ptr<MockICloudDB> & idb)1035 void MockCall(MockICloudSyncStorageInterface *iCloud, const std::shared_ptr<MockICloudDB> &idb)
1036 {
1037 EXPECT_CALL(*iCloud, FillCloudGid(_)).WillRepeatedly(Return(E_OK));
1038 EXPECT_CALL(*idb, BatchInsert(_, _, _)).WillRepeatedly(Return(OK));
1039 EXPECT_CALL(*iCloud, PutMetaData(_, _)).WillRepeatedly(Return(E_OK));
1040 EXPECT_CALL(*iCloud, GetUploadCount(_, _, _, _))
1041 .WillRepeatedly([](const std::string &, const Timestamp &, const bool, int64_t & count) {
1042 count = 2000; // total 2000
1043 return E_OK;
1044 });
1045 }
1046
1047 /**
1048 * @tc.name: UploadModeCheck018
1049 * @tc.desc: Test notify count when upload with two batch
1050 * @tc.type: FUNC
1051 * @tc.require: AR000HSNJO
1052 * @tc.author: zhangqiquan
1053 */
1054 HWTEST_F(DistributedDBCloudSyncerUploadTest, UploadModeCheck018, TestSize.Level1)
1055 {
1056 auto *iCloud = new(std::nothrow) MockICloudSyncStorageInterface();
1057 ASSERT_NE(iCloud, nullptr);
1058 std::shared_ptr<TestStorageProxy> storageProxy = std::make_shared<TestStorageProxy>(iCloud);
1059 TestCloudSyncer *cloudSyncer = new(std::nothrow) TestCloudSyncer(storageProxy);
1060 auto idb = std::make_shared<MockICloudDB>();
1061 cloudSyncer->SetMockICloudDB(idb);
1062 cloudSyncer->InitCloudSyncer(5u, SYNC_MODE_CLOUD_FORCE_PUSH);
1063
1064 CommonExpectCall(iCloud);
1065 MockCall(iCloud, idb);
1066
1067 // Batch_n CloudSyncData quantity > total count
1068 VBucket tmp = { pair<std::string, int64_t>(CloudDbConstant::MODIFY_FIELD, 1),
1069 pair<std::string, int64_t>(CloudDbConstant::CREATE_FIELD, 1) };
1070 cloudSyncer->InitCloudSyncer(5u, SYNC_MODE_CLOUD_FORCE_PUSH);
1071 CloudSyncData uploadData2(cloudSyncer->GetCurrentContextTableName());
1072 uploadData2.insData.record = std::vector<VBucket>(1000, tmp);
1073 uploadData2.insData.extend = std::vector<VBucket>(1000, tmp);
1074
1075 SyncTimeRange syncTimeRange = { .beginTime = 1u };
1076 QueryObject queryObject(Query::Select());
1077 queryObject.SetTableName(cloudSyncer->GetCurrentContextTableName());
1078 auto token = new (std::nothrow) SQLiteSingleVerRelationalContinueToken(syncTimeRange, queryObject);
1079 auto conStmtToken = static_cast<ContinueToken>(token);
1080 delete token;
1081 EXPECT_CALL(*iCloud, GetCloudData(_, _, _, _)).WillOnce([&conStmtToken, &uploadData2](
__anon1a8a43022902( const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) 1082 const TableSchema &, const Timestamp &, ContinueToken &continueStmtToken, CloudSyncData &cloudDataResult) {
1083 cloudDataResult = uploadData2;
1084 continueStmtToken = conStmtToken;
1085 return -E_UNFINISHED;
1086 });
1087
1088 CloudSyncData uploadData3(cloudSyncer->GetCurrentContextTableName());
1089 uploadData3.insData.extend = std::vector<VBucket>(2001, tmp);
1090 uploadData3.insData.record = std::vector<VBucket>(2001, tmp);
1091 EXPECT_CALL(*iCloud, GetCloudDataNext(_, _)).WillOnce(
__anon1a8a43022a02(ContinueToken &, CloudSyncData &cloudDataResult) 1092 [&uploadData3](ContinueToken &, CloudSyncData &cloudDataResult) {
1093 cloudDataResult = uploadData3;
1094 return E_OK;
1095 });
1096 std::atomic<int> callCount = 0;
__anon1a8a43022b02(const std::map<std::string, SyncProcess> &) 1097 cloudSyncer->SetCurrentCloudTaskInfos({"TABLE"}, [&callCount](const std::map<std::string, SyncProcess> &) {
1098 callCount++;
1099 });
1100 int errCode = cloudSyncer->CallDoUpload(5u, true);
1101 EXPECT_EQ(errCode, -E_INTERNAL_ERROR);
1102
1103 RuntimeContext::GetInstance()->StopTaskPool();
1104 EXPECT_EQ(callCount, 1);
1105 cloudSyncer->CallClose();
1106 RefObject::KillAndDecObjRef(cloudSyncer);
1107 storageProxy.reset();
1108 delete iCloud;
1109 idb = nullptr;
1110 }
1111 }