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_sync_manager_impl.h"
17 #include "dfs_error.h"
18 #include "service_proxy_mock.h"
19
20 namespace OHOS {
21 namespace FileManagement::CloudSync {
22 namespace Test {
23 using namespace testing::ext;
24 using namespace testing;
25 using namespace std;
26
27 class CloudSyncManagerTest : public testing::Test {
28 public:
29 static void SetUpTestCase(void);
30 static void TearDownTestCase(void);
31 void SetUp();
32 void TearDown();
33 std::shared_ptr<CloudSyncManagerImpl> managePtr_;
34 static inline std::shared_ptr<MockServiceProxy> proxy_ = nullptr;
35 };
36
37 class CloudSyncCallbackDerived : public CloudSyncCallback {
38 public:
OnSyncStateChanged(CloudSyncState state,ErrorType error)39 void OnSyncStateChanged(CloudSyncState state, ErrorType error)
40 {
41 std::cout << "OnSyncStateChanged" << std::endl;
42 }
43 };
44
SetUpTestCase(void)45 void CloudSyncManagerTest::SetUpTestCase(void)
46 {
47 std::cout << "SetUpTestCase" << std::endl;
48 proxy_ = std::make_shared<MockServiceProxy>();
49 IserviceProxy::proxy_ = proxy_;
50 }
51
TearDownTestCase(void)52 void CloudSyncManagerTest::TearDownTestCase(void)
53 {
54 std::cout << "TearDownTestCase" << std::endl;
55 IserviceProxy::proxy_.reset();
56 proxy_ = nullptr;
57 }
58
SetUp(void)59 void CloudSyncManagerTest::SetUp(void)
60 {
61 managePtr_ = make_shared<CloudSyncManagerImpl>();
62 std::cout << "SetUp" << std::endl;
63 }
64
TearDown(void)65 void CloudSyncManagerTest::TearDown(void)
66 {
67 managePtr_ = nullptr;
68 std::cout << "TearDown" << std::endl;
69 }
70
71 /**
72 * @tc.name: RegisterCallbackTest
73 * @tc.desc: Verify the RegisterCallback function.
74 * @tc.type: FUNC
75 * @tc.require: I6H5MH
76 */
77 HWTEST_F(CloudSyncManagerTest, RegisterCallbackTest, TestSize.Level1)
78 {
79 GTEST_LOG_(INFO) << "RegisterCallbackTest Start";
80 try {
81 shared_ptr<CloudSyncCallback> callback = make_shared<CloudSyncCallbackDerived>();
82 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
83 auto res = managePtr_->RegisterCallback(callback);
84 EXPECT_EQ(res, E_SA_LOAD_FAILED);
85 } catch (...) {
86 EXPECT_TRUE(false);
87 GTEST_LOG_(INFO) << " RegisterCallbackTest FAILED";
88 }
89 GTEST_LOG_(INFO) << "RegisterCallbackTest End";
90 }
91
92 /**
93 * @tc.name: StartSyncTest
94 * @tc.desc: Verify the StartSync function.
95 * @tc.type: FUNC
96 * @tc.require: I6H5MH
97 */
98 HWTEST_F(CloudSyncManagerTest, StartSyncTest, TestSize.Level1)
99 {
100 GTEST_LOG_(INFO) << "StartSyncTest Start";
101 try {
102 bool forceFlag = false;
103 shared_ptr<CloudSyncCallback> callback = make_shared<CloudSyncCallbackDerived>();
104 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
105 auto res = managePtr_->StartSync();
106 EXPECT_EQ(res, E_SA_LOAD_FAILED);
107 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
108 res = managePtr_->StartSync(forceFlag, callback);
109 EXPECT_EQ(res, E_SA_LOAD_FAILED);
110 } catch (...) {
111 EXPECT_TRUE(false);
112 GTEST_LOG_(INFO) << " StartSyncTest FAILED";
113 }
114 GTEST_LOG_(INFO) << "StartSyncTest End";
115 }
116
117 /*
118 * @tc.name: StopSyncTest
119 * @tc.desc: Verify the StopSync function.
120 * @tc.type: FUNC
121 * @tc.require: I6H5MH
122 */
123 HWTEST_F(CloudSyncManagerTest, StopSyncTest, TestSize.Level1)
124 {
125 GTEST_LOG_(INFO) << "StopSyncTest Start";
126 try {
127 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
128 int res = managePtr_->StopSync();
129 EXPECT_EQ(res, E_SA_LOAD_FAILED);
130 } catch (...) {
131 EXPECT_TRUE(false);
132 GTEST_LOG_(INFO) << " StopSyncTest FAILED";
133 }
134 GTEST_LOG_(INFO) << "StopSyncTest End";
135 }
136
137 /*
138 * @tc.name: ChangeAppSwitchTest
139 * @tc.desc: Verify the ChangeAppSwitch function.
140 * @tc.type: FUNC
141 * @tc.require: I6H5MH
142 */
143 HWTEST_F(CloudSyncManagerTest, ChangeAppSwitchTest, TestSize.Level1)
144 {
145 GTEST_LOG_(INFO) << "ChangeAppSwitchTest Start";
146 try {
147 std::string accoutId = "accoutId";
148 std::string bundleName = "bundleName";
149 bool status = true;
150 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
151 auto res = managePtr_->ChangeAppSwitch(accoutId, bundleName, status);
152 EXPECT_EQ(res, E_SA_LOAD_FAILED);
153 } catch (...) {
154 EXPECT_TRUE(false);
155 GTEST_LOG_(INFO) << " ChangeAppSwitchTest FAILED";
156 }
157 GTEST_LOG_(INFO) << "ChangeAppSwitchTest End";
158 }
159
160 /*
161 * @tc.name: NotifyDataChangeTest
162 * @tc.desc: Verify the NotifyDataChange function.
163 * @tc.type: FUNC
164 * @tc.require: I6H5MH
165 */
166 HWTEST_F(CloudSyncManagerTest, NotifyDataChangeTest, TestSize.Level1)
167 {
168 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
169 try {
170 std::string accoutId = "accoutId";
171 std::string bundleName = "bundleName";
172 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
173 auto res = managePtr_->NotifyDataChange(accoutId, bundleName);
174 EXPECT_EQ(res, E_SA_LOAD_FAILED);
175 } catch (...) {
176 EXPECT_TRUE(false);
177 GTEST_LOG_(INFO) << " NotifyDataChangeTest FAILED";
178 }
179 GTEST_LOG_(INFO) << "NotifyDataChangeTest End";
180 }
181
182 /*
183 * @tc.name: StartDownloadFileTest
184 * @tc.desc: Verify the StartDownloadFile function.
185 * @tc.type: FUNC
186 * @tc.require: I6H5MH
187 */
188 HWTEST_F(CloudSyncManagerTest, StartDownloadFileTest, TestSize.Level1)
189 {
190 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
191 try {
192 std::string uri = "uri";
193 int64_t downloadId = 0;
194 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
195 auto res = managePtr_->StartDownloadFile(uri, nullptr, downloadId);
196 EXPECT_EQ(res, E_SA_LOAD_FAILED);
197 } catch (...) {
198 EXPECT_TRUE(false);
199 GTEST_LOG_(INFO) << " StartDownloadFileTest FAILED";
200 }
201 GTEST_LOG_(INFO) << "StartDownloadFileTest End";
202 }
203
204 /*
205 * @tc.name: StopDownloadFileTest
206 * @tc.desc: Verify the StopDownloadFile function.
207 * @tc.type: FUNC
208 * @tc.require: I6H5MH
209 */
210 HWTEST_F(CloudSyncManagerTest, StopDownloadFileTest, TestSize.Level1)
211 {
212 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
213 try {
214 int64_t downloadId = 0;
215 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
216 auto res = managePtr_->StopDownloadFile(downloadId, true);
217 EXPECT_EQ(res, E_SA_LOAD_FAILED);
218 } catch (...) {
219 EXPECT_TRUE(false);
220 GTEST_LOG_(INFO) << " StopDownloadFileTest FAILED";
221 }
222 GTEST_LOG_(INFO) << "StopDownloadFileTest End";
223 }
224
225 /*
226 * @tc.name: EnableCloudTest
227 * @tc.desc: Verify the EnableCloud function.
228 * @tc.type: FUNC
229 * @tc.require: I6H5MH
230 */
231 HWTEST_F(CloudSyncManagerTest, EnableCloudTest, TestSize.Level1)
232 {
233 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
234 try {
235 std::string accoutId = "accoutId";
236 SwitchDataObj switchData;
237 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
238 auto res = managePtr_->EnableCloud(accoutId, switchData);
239 EXPECT_EQ(res, E_SA_LOAD_FAILED);
240 } catch (...) {
241 EXPECT_TRUE(false);
242 GTEST_LOG_(INFO) << " EnableCloudTest FAILED";
243 }
244 GTEST_LOG_(INFO) << "EnableCloudTest End";
245 }
246
247 /*
248 * @tc.name: DisableCloudTest
249 * @tc.desc: Verify the DisableCloud function.
250 * @tc.type: FUNC
251 * @tc.require: I6H5MH
252 */
253 HWTEST_F(CloudSyncManagerTest, DisableCloudTest, TestSize.Level1)
254 {
255 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
256 try {
257 std::string accoutId = "accoutId";
258 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
259 auto res = managePtr_->DisableCloud(accoutId);
260 EXPECT_EQ(res, E_SA_LOAD_FAILED);
261 } catch (...) {
262 EXPECT_TRUE(false);
263 GTEST_LOG_(INFO) << " DisableCloudTest FAILED";
264 }
265 GTEST_LOG_(INFO) << "DisableCloudTest End";
266 }
267
268 /*
269 * @tc.name: CleanTest
270 * @tc.desc: Verify the Clean function.
271 * @tc.type: FUNC
272 * @tc.require: I6H5MH
273 */
274 HWTEST_F(CloudSyncManagerTest, CleanTest, TestSize.Level1)
275 {
276 GTEST_LOG_(INFO) << "NotifyDataChangeTest Start";
277 try {
278 std::string accoutId = "accoutId";
279 CleanOptions cleanOptions;
280 EXPECT_CALL(*proxy_, GetInstance()).WillOnce(Return(nullptr));
281 auto res = managePtr_->Clean(accoutId, cleanOptions);
282 EXPECT_EQ(res, E_SA_LOAD_FAILED);
283 } catch (...) {
284 EXPECT_TRUE(false);
285 GTEST_LOG_(INFO) << " CleanTest FAILED";
286 }
287 GTEST_LOG_(INFO) << "CleanTest End";
288 }
289
290 } // namespace Test
291 } // namespace FileManagement::CloudSync
292 } // namespace OHOS
293