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 
16 #define LOG_TAG "CloudTest"
17 #include <string>
18 
19 #include "account/account_delegate.h"
20 #include "cloud/cloud_server.h"
21 #include "cloud/sync_event.h"
22 #include "gtest/gtest.h"
23 #include "ipc_skeleton.h"
24 #include "metadata/meta_data_manager.h"
25 #include "mock/db_store_mock.h"
26 using namespace testing::ext;
27 using namespace OHOS::DistributedData;
28 using Database = SchemaMeta::Database;
29 namespace OHOS::Test {
30 class CloudTest : public testing::Test {
31 public:
32     static void SetUpTestCase(void);
TearDownTestCase(void)33     static void TearDownTestCase(void){};
SetUp()34     void SetUp(){};
TearDown()35     void TearDown(){};
36 
37 protected:
38     static constexpr const char* TEST_CLOUD_BUNDLE = "test_cloud_bundleName";
39     static constexpr const char* TEST_CLOUD_STORE = "test_cloud_database_name";
40     static std::shared_ptr<DBStoreMock> dbStoreMock_;
41 };
42 std::shared_ptr<DBStoreMock> CloudTest::dbStoreMock_ = std::make_shared<DBStoreMock>();
43 
SetUpTestCase(void)44 void CloudTest::SetUpTestCase(void)
45 {
46     MetaDataManager::GetInstance().Initialize(dbStoreMock_, nullptr);
47 }
48 
49 /**
50 * @tc.name: EventInfo
51 * @tc.desc:
52 * @tc.type: FUNC
53 * @tc.require:
54 */
55 HWTEST_F(CloudTest, EventInfo, TestSize.Level1)
56 {
57     const int32_t mode = 1;
58     const int32_t wait = 10;
59     const bool retry = true;
60     std::shared_ptr<GenQuery> query = nullptr;
61     int sign = 0;
__anon6affcb7e0102(const GenDetails& details) 62     auto async = [&sign](const GenDetails& details) {
63         ++sign;
64     };
65     SyncEvent::EventInfo eventInfo1(mode, wait, retry, query, async);
66     SyncEvent::EventInfo eventInfo2(std::move(eventInfo1));
67     SyncEvent::EventInfo eventInfo3 = std::move(eventInfo2);
68     StoreInfo storeInfo{ IPCSkeleton::GetCallingTokenID(), TEST_CLOUD_BUNDLE, TEST_CLOUD_STORE, 0 };
69     SyncEvent evt(storeInfo, eventInfo3);
70     EXPECT_EQ(evt.GetMode(), mode);
71     EXPECT_EQ(evt.GetWait(), wait);
72     EXPECT_EQ(evt.AutoRetry(), retry);
73     EXPECT_EQ(evt.GetQuery(), query);
74     evt.GetAsyncDetail()(GenDetails());
75     EXPECT_NE(0, sign);
76 }
77 
78 /**
79 * @tc.name: Serializable_Marshal
80 * @tc.desc:
81 * @tc.type: FUNC
82 * @tc.require:
83 */
84 HWTEST_F(CloudTest, Serializable_Marshal, TestSize.Level1)
85 {
86     SchemaMeta schemaMeta;
87     bool ret = schemaMeta.IsValid();
88     EXPECT_EQ(false, ret);
89 
90     SchemaMeta::Database database;
91     database.name = TEST_CLOUD_STORE;
92     database.alias = "database_alias_test";
93 
94     schemaMeta.version = 1;
95     schemaMeta.bundleName = TEST_CLOUD_BUNDLE;
96     schemaMeta.databases.emplace_back(database);
97     ret = schemaMeta.IsValid();
98     EXPECT_EQ(true, ret);
99 
100     Serializable::json node = schemaMeta.Marshall();
101     SchemaMeta schemaMeta2;
102     schemaMeta2.Unmarshal(node);
103 
104     EXPECT_EQ(schemaMeta.version, schemaMeta2.version);
105     EXPECT_EQ(schemaMeta.bundleName, schemaMeta2.bundleName);
106     Database database2 = schemaMeta2.GetDataBase(TEST_CLOUD_STORE);
107     EXPECT_EQ(database.alias, database2.alias);
108 
109     std::string storeId = "storeId";
110     Database database3 = schemaMeta2.GetDataBase(storeId);
111     EXPECT_NE(database.alias, database3.alias);
112 }
113 
114 /**
115 * @tc.name: Field_Marshal
116 * @tc.desc:
117 * @tc.type: FUNC
118 * @tc.require:
119 */
120 HWTEST_F(CloudTest, Field_Marshal, TestSize.Level1)
121 {
122     Field field;
123     field.colName = "field_name1_test";
124     field.alias = "field_alias1_test";
125     field.type = 1;
126     field.primary = true;
127     field.nullable = false;
128 
129     Serializable::json node = field.Marshall();
130     Field field2;
131     field2.Unmarshal(node);
132 
133     EXPECT_EQ(field.colName, field2.colName);
134     EXPECT_EQ(field.alias, field2.alias);
135     EXPECT_EQ(field.type, field2.type);
136     EXPECT_EQ(field.primary, field2.primary);
137     EXPECT_EQ(field.nullable, field2.nullable);
138 }
139 
140 /**
141 * @tc.name: Database_Marshal
142 * @tc.desc:
143 * @tc.type: FUNC
144 * @tc.require:
145 */
146 HWTEST_F(CloudTest, Database_Marshal, TestSize.Level1)
147 {
148     SchemaMeta::Table table1;
149     table1.name = "test_cloud_table_name1";
150     table1.alias = "test_cloud_table_alias1";
151     SchemaMeta::Table table2;
152     table2.name = "test_cloud_table_name2";
153     table2.alias = "test_cloud_table_alias2";
154 
155     SchemaMeta::Database database1;
156     database1.name = TEST_CLOUD_STORE;
157     database1.alias = "test_cloud_database_alias";
158     database1.tables.emplace_back(table1);
159     database1.tables.emplace_back(table2);
160 
161     Serializable::json node = database1.Marshall();
162     SchemaMeta::Database database2;
163     database2.Unmarshal(node);
164 
165     EXPECT_EQ(database1.name, database2.name);
166     EXPECT_EQ(database1.alias, database2.alias);
167     std::vector<std::string> tableNames1 = database1.GetTableNames();
168     std::vector<std::string> tableNames2 = database2.GetTableNames();
169     EXPECT_EQ(tableNames1.size(), tableNames2.size());
170     for (uint32_t i = 0; i < tableNames1.size(); ++i) {
171         EXPECT_EQ(tableNames1[i], tableNames2[i]);
172     }
173 }
174 
175 /**
176  * @tc.name: Load old cloudInfo
177  * @tc.desc: The obtained maxUploadBatchNumber and maxUploadBatchSize are not equal to 0
178  * @tc.type: FUNC
179  * @tc.require:
180  * @tc.author: ht
181  */
182 HWTEST_F(CloudTest, CloudInfoUpgrade, TestSize.Level0)
183 {
184     int32_t defaultUser = 100;
185     CloudInfo oldInfo;
186     auto user = defaultUser;
187     oldInfo.user = user;
188     EXPECT_NE(oldInfo.maxNumber, CloudInfo::DEFAULT_BATCH_NUMBER);
189     EXPECT_NE(oldInfo.maxSize, CloudInfo::DEFAULT_BATCH_SIZE);
190     ASSERT_TRUE(MetaDataManager::GetInstance().SaveMeta(oldInfo.GetKey(), oldInfo, true));
191     CloudInfo newInfo;
192     ASSERT_TRUE(MetaDataManager::GetInstance().LoadMeta(oldInfo.GetKey(), newInfo, true));
193     EXPECT_EQ(newInfo.maxNumber, CloudInfo::DEFAULT_BATCH_NUMBER);
194     EXPECT_EQ(newInfo.maxSize, CloudInfo::DEFAULT_BATCH_SIZE);
195 }
196 } // namespace OHOS::Test