1 /*
2 * Copyright (c) 2025 Huawei Device Co., Ltd.
3 * Licensed under the Apache License, Version 2.0 (the "License");
4 * you may not use this file except in compliance with the License.
5 * You may obtain a copy of the License at
6 *
7 * http://www.apache.org/licenses/LICENSE-2.0
8 *
9 * Unless required by applicable law or agreed to in writing, software
10 * distributed under the License is distributed on an "AS IS" BASIS,
11 * WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
12 * See the License for the specific language governing permissions and
13 * limitations under the License.
14 */
15
16 #include "cloud_sync_core.h"
17
18 #include <gmock/gmock.h>
19 #include <gtest/gtest.h>
20 #include <sys/types.h>
21 #include <sys/xattr.h>
22
23 #include "cloud_sync_manager.h"
24 #include "dfs_error.h"
25 #include "uri.h"
26 #include "utils_log.h"
27
28 namespace OHOS::FileManagement::CloudDisk::Test {
29 using namespace testing;
30 using namespace testing::ext;
31 using namespace std;
32 using namespace OHOS::FileManagement::CloudSync;
33
34 const int32_t E_INVAL = 13900020;
35
36 class CloudSyncCoreTest : public testing::Test {
37 public:
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 };
43
SetUpTestCase(void)44 void CloudSyncCoreTest::SetUpTestCase(void)
45 {
46 GTEST_LOG_(INFO) << "SetUpTestCase";
47 }
48
TearDownTestCase(void)49 void CloudSyncCoreTest::TearDownTestCase(void)
50 {
51 GTEST_LOG_(INFO) << "TearDownTestCase";
52 }
53
SetUp(void)54 void CloudSyncCoreTest::SetUp(void)
55 {
56 GTEST_LOG_(INFO) << "SetUp";
57 }
58
TearDown(void)59 void CloudSyncCoreTest::TearDown(void)
60 {
61 GTEST_LOG_(INFO) << "TearDown";
62 }
63
64 /**
65 * @tc.name: Constructor
66 * @tc.desc: Verify the CloudSyncCore::Constructor function
67 * @tc.type: FUNC
68 */
69 HWTEST_F(CloudSyncCoreTest, ConstructorTest1, TestSize.Level1)
70 {
71 auto data = CloudSyncCore::Constructor();
72 EXPECT_TRUE(data.IsSuccess());
73 }
74
75 /**
76 * @tc.name: GetBundleName
77 * @tc.desc: Verify the CloudSyncCore::GetBundleName function
78 * @tc.type: FUNC
79 */
80 HWTEST_F(CloudSyncCoreTest, GetBundleNameTest1, TestSize.Level1)
81 {
82 const CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
83 string ret = cloudSync->GetBundleName();
84 EXPECT_EQ(ret, "");
85 }
86
87 /**
88 * @tc.name: DoOn
89 * @tc.desc: Verify the CloudSyncCore::DoOn function
90 * @tc.type: FUNC
91 * @tc.require: IC7I52
92 */
93 HWTEST_F(CloudSyncCoreTest, DoOnTest1, TestSize.Level1)
94 {
95 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
96 auto callback = std::make_shared<CloudSyncCallbackAniImpl>(nullptr, nullptr);
97 std::string event = "progress";
98 auto ret = cloudSync->DoOn(event, callback);
99 EXPECT_FALSE(ret.IsSuccess());
100 const auto &err = ret.GetError();
101 int errorCode = err.GetErrNo();
102 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
103 }
104
105 /**
106 * @tc.name: DoOff
107 * @tc.desc: Verify the CloudSyncCore::DoOff function
108 * @tc.type: FUNC
109 */
110 HWTEST_F(CloudSyncCoreTest, DoOffTest3, TestSize.Level1)
111 {
112 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
113 auto callback = std::make_shared<CloudSyncCallbackAniImpl>(nullptr, nullptr);
114 std::string event = "progress";
115 auto ret = cloudSync->DoOn(event, callback);
116 EXPECT_FALSE(ret.IsSuccess());
117 ret = cloudSync->DoOff(event);
118 EXPECT_FALSE(ret.IsSuccess());
119 const auto &err = ret.GetError();
120 int errorCode = err.GetErrNo();
121 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
122 }
123
124 /**
125 * @tc.name: DoOn
126 * @tc.desc: Verify the CloudSyncCore::DoOn function
127 * @tc.type: FUNC
128 */
129 HWTEST_F(CloudSyncCoreTest, DoOnTest2, TestSize.Level1)
130 {
131 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
132 auto callback = std::make_shared<CloudSyncCallbackAniImpl>(nullptr, nullptr);
133 std::string event = "";
134 auto ret = cloudSync->DoOn(event, callback);
135 EXPECT_FALSE(ret.IsSuccess());
136 const auto &err = ret.GetError();
137 int errorCode = err.GetErrNo();
138 EXPECT_EQ(errorCode, E_PARAMS);
139 }
140
141 /**
142 * @tc.name: DoOn
143 * @tc.desc: Verify the CloudSyncCore::DoOn function
144 * @tc.type: FUNC
145 */
146 HWTEST_F(CloudSyncCoreTest, DoOnTest3, TestSize.Level1)
147 {
148 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
149 auto callback = std::make_shared<CloudSyncCallbackAniImpl>(nullptr, nullptr);
150 std::string event = "progress";
151 auto ret = cloudSync->DoOn(event, callback);
152 ret = cloudSync->DoOn(event, callback);
153 EXPECT_TRUE(ret.IsSuccess());
154 }
155
156 /**
157 * @tc.name: DoOff
158 * @tc.desc: Verify the CloudSyncCore::DoOff function
159 * @tc.type: FUNC
160 */
161 HWTEST_F(CloudSyncCoreTest, DoOffTest1, TestSize.Level1)
162 {
163 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
164 std::string event = "progress";
165 auto ret = cloudSync->DoOff(event);
166 EXPECT_FALSE(ret.IsSuccess());
167 const auto &err = ret.GetError();
168 int errorCode = err.GetErrNo();
169 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
170 }
171
172 /**
173 * @tc.name: DoOff
174 * @tc.desc: Verify the CloudSyncCore::DoOff function
175 * @tc.type: FUNC
176 */
177 HWTEST_F(CloudSyncCoreTest, DoOffTest2, TestSize.Level1)
178 {
179 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
180 std::string event = "";
181 auto ret = cloudSync->DoOff(event);
182 EXPECT_FALSE(ret.IsSuccess());
183 const auto &err = ret.GetError();
184 int errorCode = err.GetErrNo();
185 EXPECT_EQ(errorCode, E_PARAMS);
186 }
187
188 /**
189 * @tc.name: DoStart
190 * @tc.desc: Verify the CloudSyncCore::DoStart function
191 * @tc.type: FUNC
192 */
193 HWTEST_F(CloudSyncCoreTest, DoStartTest1, TestSize.Level1)
194 {
195 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
196 auto ret = cloudSync->DoStart();
197 EXPECT_FALSE(ret.IsSuccess());
198 const auto &err = ret.GetError();
199 int errorCode = err.GetErrNo();
200 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
201 }
202
203 /**
204 * @tc.name: DoStart
205 * @tc.desc: Verify the CloudSyncCore::DoStart function
206 * @tc.type: FUNC
207 */
208 HWTEST_F(CloudSyncCoreTest, DoStartTest2, TestSize.Level1)
209 {
210 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
211 auto ret = cloudSync->DoStart();
212 EXPECT_FALSE(ret.IsSuccess());
213 const auto &err = ret.GetError();
214 int errorCode = err.GetErrNo();
215 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
216 ret = cloudSync->DoStop();
217 EXPECT_FALSE(ret.IsSuccess());
218 const auto &error = ret.GetError();
219 errorCode = error.GetErrNo();
220 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
221 }
222
223 /**
224 * @tc.name: DoStop
225 * @tc.desc: Verify the CloudSyncCore::DoStop function
226 * @tc.type: FUNC
227 */
228 HWTEST_F(CloudSyncCoreTest, DoStopTest1, TestSize.Level1)
229 {
230 CloudSyncCore *cloudSync = CloudSyncCore::Constructor().GetData().value();
231 auto ret = cloudSync->DoStop();
232 EXPECT_FALSE(ret.IsSuccess());
233 const auto &err = ret.GetError();
234 int errorCode = err.GetErrNo();
235 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
236 }
237
238 /**
239 * @tc.name: DoGetFileSyncState
240 * @tc.desc: Verify the CloudSyncCore::DoGetFileSyncState function
241 * @tc.type: FUNC
242 */
243 HWTEST_F(CloudSyncCoreTest, DoGetFileSyncStateTest1, TestSize.Level1)
244 {
245 string filePath = "/test/test.txt";
246 auto ret = CloudSyncCore::DoGetFileSyncState(filePath);
247 EXPECT_FALSE(ret.IsSuccess());
248 const auto &err = ret.GetError();
249 int errorCode = err.GetErrNo();
250 EXPECT_EQ(errorCode, E_INVAL);
251 }
252
253 /**
254 * @tc.name: DoOptimizeStorage
255 * @tc.desc: Verify the CloudSyncCore::DoOptimizeStorage function
256 * @tc.type: FUNC
257 */
258 HWTEST_F(CloudSyncCoreTest, DoOptimizeStorageTest1, TestSize.Level1)
259 {
260 auto ret = CloudSyncCore::DoOptimizeStorage();
261 EXPECT_FALSE(ret.IsSuccess());
262 const auto &err = ret.GetError();
263 int errorCode = err.GetErrNo();
264 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
265 }
266
267 /**
268 * @tc.name: DoStartOptimizeStorage
269 * @tc.desc: Verify the CloudSyncCore::DoStartOptimizeStorage
270 * @tc.type: FUNC
271 */
272 HWTEST_F(CloudSyncCoreTest, DoStartOptimizeStorageTest1, TestSize.Level1)
273 {
274 OptimizeSpaceOptions optimizeOptions {};
275 int64_t totalSize = 100;
276 int32_t agingDays = 30;
277 optimizeOptions.totalSize = totalSize;
278 optimizeOptions.agingDays = agingDays;
279 auto callback = std::make_shared<CloudOptimizeCallbackAniImpl>(nullptr, nullptr);
280 auto ret = CloudSyncCore::DoStartOptimizeStorage(optimizeOptions, callback);
281 EXPECT_FALSE(ret.IsSuccess());
282 const auto &err = ret.GetError();
283 int errorCode = err.GetErrNo();
284 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
285 }
286
287 /**
288 * @tc.name: DoStopOptimizeStorage
289 * @tc.desc: Verify the CloudSyncCore::DoStopOptimizeStorage function
290 * @tc.type: FUNC
291 */
292 HWTEST_F(CloudSyncCoreTest, DoStopOptimizeStorageTest1, TestSize.Level1)
293 {
294 auto ret = CloudSyncCore::DoStopOptimizeStorage();
295 EXPECT_FALSE(ret.IsSuccess());
296 const auto &err = ret.GetError();
297 int errorCode = err.GetErrNo();
298 EXPECT_EQ(errorCode, OHOS::FileManagement::E_PERMISSION);
299 }
300 } // namespace OHOS::FileManagement::CloudDisk::Test