1 /* 2 * Copyright (c) 2024 Huawei Device Co., Ltd. 3 * Licensed under the Apache License, Version 2.0 (the "License"); 4 * you may not use this file except in compliance with the License. 5 * You may obtain a copy of the License at 6 * 7 * http://www.apache.org/licenses/LICENSE-2.0 8 * 9 * Unless required by applicable law or agreed to in writing, software 10 * distributed under the License is distributed on an "AS IS" BASIS, 11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied. 12 * See the License for the specific language governing permissions and 13 * limitations under the License. 14 */ 15 #define LOG_TAG "RdbCloudTest" 16 17 #include "rdb_cloud.h" 18 19 #include "gtest/gtest.h" 20 #include "log_print.h" 21 #include "rdb_cloud_data_translate.h" 22 23 using namespace testing::ext; 24 using namespace OHOS::DistributedData; 25 using namespace OHOS::DistributedRdb; 26 using DBVBucket = DistributedDB::VBucket; 27 using DBStatus = DistributedDB::DBStatus; 28 std::vector<DBVBucket> g_DBVBucket = { 29 { 30 {"#gid", {"0000000"}}, 31 {"#flag", {true}}, 32 {"#value", {int64_t(100)}}, 33 {"#float", {double(100)}}, 34 {"#_type", {int64_t(1)}}, 35 {"#_query", {Bytes({ 1, 2, 3, 4 })}} 36 } 37 }; 38 namespace OHOS::Test { 39 namespace DistributedRDBTest { 40 class RdbCloudTest : public testing::Test { 41 public: SetUpTestCase(void)42 static void SetUpTestCase(void){}; TearDownTestCase(void)43 static void TearDownTestCase(void){}; SetUp()44 void SetUp(){}; TearDown()45 void TearDown(){}; 46 protected: 47 }; 48 49 /** 50 * @tc.name: RdbCloudTest001 51 * @tc.desc: RdbCloud BatchInsert BatchUpdate BatchDelete test. 52 * @tc.type: FUNC 53 * @tc.require: 54 * @tc.author: SQL 55 */ 56 HWTEST_F(RdbCloudTest, RdbCloudTest001, TestSize.Level1) 57 { 58 BindAssets bindAssets; 59 Bytes bytes; 60 std::shared_ptr<CloudDB> cloudDB = std::make_shared<CloudDB>(); 61 RdbCloud rdbCloud(cloudDB, &bindAssets); 62 std::string tableName = "testTable"; 63 auto result = rdbCloud.BatchInsert(tableName, std::move(g_DBVBucket), g_DBVBucket); 64 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 65 result = rdbCloud.BatchUpdate(tableName, std::move(g_DBVBucket), g_DBVBucket); 66 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 67 result = rdbCloud.BatchDelete(tableName, g_DBVBucket); 68 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 69 } 70 71 /** 72 * @tc.name: RdbCloudTest002 73 * @tc.desc: RdbCloud Query PreSharing HeartBeat Close test. 74 * @tc.type: FUNC 75 * @tc.require: 76 * @tc.author: SQL 77 */ 78 HWTEST_F(RdbCloudTest, RdbCloudTest002, TestSize.Level1) 79 { 80 BindAssets bindAssets; 81 std::shared_ptr<CloudDB> cloudDB = std::make_shared<CloudDB>(); 82 RdbCloud rdbCloud(cloudDB, &bindAssets); 83 std::string tableName = "testTable"; 84 rdbCloud.Lock(); 85 auto result = rdbCloud.BatchInsert(tableName, std::move(g_DBVBucket), g_DBVBucket); 86 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 87 DBVBucket extends = { 88 {"#gid", {"0000000"}}, {"#flag", {true}}, {"#value", {int64_t(100)}}, {"#float", {double(100)}}, 89 {"#_type", {int64_t(1)}}, {"#_query", {Bytes({ 1, 2, 3, 4 })}} 90 }; 91 result = rdbCloud.Query(tableName, extends, g_DBVBucket); 92 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 93 std::vector<VBucket> vBuckets = { 94 {{"#gid", {"0000000"}}, {"#flag", {true}}, {"#value", {int64_t(100)}}, {"#float", {double(100)}}, 95 {"#_type", {int64_t(1)}}, {"#_query", {Bytes({ 1, 2, 3, 4 })}}} 96 }; 97 rdbCloud.PreSharing(tableName, vBuckets); 98 result = rdbCloud.HeartBeat(); 99 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 100 rdbCloud.UnLock(); 101 rdbCloud.GetEmptyCursor(tableName); 102 result = rdbCloud.Close(); 103 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 104 } 105 106 /** 107 * @tc.name: RdbCloudTest003 108 * @tc.desc: RdbCloud Query error test. 109 * @tc.type: FUNC 110 * @tc.require: 111 * @tc.author: SQL 112 */ 113 HWTEST_F(RdbCloudTest, RdbCloudTest003, TestSize.Level1) 114 { 115 BindAssets bindAssets; 116 bindAssets.bindAssets = nullptr; 117 std::shared_ptr<CloudDB> cloudDB = std::make_shared<CloudDB>(); 118 RdbCloud rdbCloud(cloudDB, &bindAssets); 119 std::string tableName = "testTable"; 120 DBVBucket extends = { 121 {"#gid", {"0000000"}}, {"#flag", {true}}, {"#value", {int64_t(100)}}, {"#float", {double(100)}}, 122 {"#_type", {int64_t(1)}} 123 }; 124 std::vector<DBVBucket> data = { 125 {{"#gid", {"0000000"}}, {"#flag", {true}}, {"#value", {int64_t(100)}}, {"#float", {double(100)}}} 126 }; 127 auto result = rdbCloud.Query(tableName, extends, data); 128 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 129 130 extends = { 131 {"#gid", {"0000000"}}, {"#flag", {true}}, {"#value", {int64_t(100)}}, {"#float", {double(100)}}, 132 {"#_query", {Bytes({ 1, 2, 3, 4 })}} 133 }; 134 result = rdbCloud.Query(tableName, extends, data); 135 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 136 137 extends = { 138 {"#gid", {"0000000"}}, {"#flag", {true}}, {"#value", {int64_t(100)}}, {"#float", {double(100)}}, 139 {"#_type", {int64_t(0)}} 140 }; 141 result = rdbCloud.Query(tableName, extends, data); 142 EXPECT_EQ(result, DBStatus::CLOUD_ERROR); 143 } 144 145 /** 146 * @tc.name: ConvertStatus 147 * @tc.desc: RdbCloud ConvertStatus function test. 148 * @tc.type: FUNC 149 * @tc.require: 150 * @tc.author: SQL 151 */ 152 HWTEST_F(RdbCloudTest, ConvertStatus, TestSize.Level1) 153 { 154 BindAssets bindAssets; 155 std::shared_ptr<CloudDB> cloudDB = std::make_shared<CloudDB>(); 156 RdbCloud rdbCloud(cloudDB, &bindAssets); 157 auto result = rdbCloud.ConvertStatus(GeneralError::E_OK); 158 EXPECT_EQ(result, DBStatus::OK); 159 result = rdbCloud.ConvertStatus(GeneralError::E_NETWORK_ERROR); 160 EXPECT_EQ(result, DBStatus::CLOUD_NETWORK_ERROR); 161 result = rdbCloud.ConvertStatus(GeneralError::E_LOCKED_BY_OTHERS); 162 EXPECT_EQ(result, DBStatus::CLOUD_LOCK_ERROR); 163 result = rdbCloud.ConvertStatus(GeneralError::E_RECODE_LIMIT_EXCEEDED); 164 EXPECT_EQ(result, DBStatus::CLOUD_FULL_RECORDS); 165 result = rdbCloud.ConvertStatus(GeneralError::E_NO_SPACE_FOR_ASSET); 166 EXPECT_EQ(result, DBStatus::CLOUD_ASSET_SPACE_INSUFFICIENT); 167 result = rdbCloud.ConvertStatus(GeneralError::E_RECORD_EXIST_CONFLICT); 168 EXPECT_EQ(result, DBStatus::CLOUD_RECORD_EXIST_CONFLICT); 169 } 170 171 /** 172 * @tc.name: BlobToAssets 173 * @tc.desc: rdb_cloud_data_translate BlobToAsset error test. 174 * @tc.type: FUNC 175 * @tc.require: 176 * @tc.author: SQL 177 */ 178 HWTEST_F(RdbCloudTest, BlobToAssets, TestSize.Level1) 179 { 180 RdbCloudDataTranslate rdbTranslate; 181 DistributedDB::Asset asset = { 182 .name = "", 183 .assetId = "", 184 .subpath = "", 185 .uri = "", 186 .modifyTime = "", 187 .createTime = "", 188 .size = "", 189 .hash = "" 190 }; 191 std::vector<uint8_t> blob; 192 auto result = rdbTranslate.BlobToAsset(blob); 193 EXPECT_EQ(result, asset); 194 195 DistributedDB::Assets assets; 196 blob = rdbTranslate.AssetsToBlob(assets); 197 auto results = rdbTranslate.BlobToAssets(blob); 198 EXPECT_EQ(results, assets); 199 } 200 } // namespace DistributedRDBTest 201 } // namespace OHOS::Test