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