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 <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "data_sync/data_sync_manager.h"
20 #include "dfs_error.h"
21 #include "sync_rule/battery_status.h"
22 #include "sync_rule/cloud_status.h"
23
24 namespace OHOS::FileManagement::CloudSync::Test {
25 using namespace testing;
26 using namespace testing::ext;
27 using namespace std;
28
29 const int USER_ID = 100;
30 const std::string BUND_NAME = "com.ohos.photos";
31 const std::string BUND_NAME_TEST = "com.ohos.photos";
32 class DataSyncManagerTest : public testing::Test {
33 public:
34 enum Action {
35 RETAIN_DATA = 0,
36 CLEAR_DATA
37 };
38 static void SetUpTestCase(void);
39 static void TearDownTestCase(void);
40 void SetUp();
41 void TearDown();
42 shared_ptr<DataSyncManager> dataSyncManager_;
43 };
SetUpTestCase(void)44 void DataSyncManagerTest::SetUpTestCase(void)
45 {
46 GTEST_LOG_(INFO) << "SetUpTestCase";
47 }
48
TearDownTestCase(void)49 void DataSyncManagerTest::TearDownTestCase(void)
50 {
51 GTEST_LOG_(INFO) << "TearDownTestCase";
52 }
53
SetUp(void)54 void DataSyncManagerTest::SetUp(void)
55 {
56 GTEST_LOG_(INFO) << "SetUp";
57 dataSyncManager_ = make_shared<DataSyncManager>();
58 }
59
TearDown(void)60 void DataSyncManagerTest::TearDown(void)
61 {
62 GTEST_LOG_(INFO) << "TearDown";
63 }
64
65 /**
66 * @tc.name: GetDataSyncerTest
67 * @tc.desc: Verify the GetDataSyncer function
68 * @tc.type: FUNC
69 * @tc.require: I6JPKG
70 */
71 HWTEST_F(DataSyncManagerTest, GetDataSyncerTest, TestSize.Level1)
72 {
73 auto dataSyncer = dataSyncManager_->GetDataSyncer(BUND_NAME_TEST, USER_ID);
74 EXPECT_EQ(USER_ID, dataSyncer->GetUserId());
75 EXPECT_EQ(BUND_NAME_TEST, dataSyncer->GetBundleName());
76 }
77
78 /**
79 * @tc.name: GetExistDataSyncerTest
80 * @tc.desc: Verify the GetDataSyncer function
81 * @tc.type: FUNC
82 * @tc.require: I6JPKG
83 */
84 HWTEST_F(DataSyncManagerTest, GetExistDataSyncerTest, TestSize.Level1)
85 {
86 auto dataSyncer = dataSyncManager_->GetDataSyncer(BUND_NAME_TEST, USER_ID);
87 EXPECT_EQ(USER_ID, dataSyncer->GetUserId());
88 EXPECT_EQ(BUND_NAME_TEST, dataSyncer->GetBundleName());
89
90 dataSyncer = dataSyncManager_->GetDataSyncer(BUND_NAME_TEST, USER_ID);
91 EXPECT_EQ(USER_ID, dataSyncer->GetUserId());
92 EXPECT_EQ(BUND_NAME_TEST, dataSyncer->GetBundleName());
93 EXPECT_EQ(dataSyncManager_->dataSyncersMap_.Size(), 1);
94 }
95
96 /**
97 * @tc.name: GetDataSyncerdifferentBundleNameTest
98 * @tc.desc: Verify the GetDataSyncer function
99 * @tc.type: FUNC
100 * @tc.require: I6JPKG
101 */
102 HWTEST_F(DataSyncManagerTest, GetDataSyncerdifferentBundleNameTest, TestSize.Level1)
103 {
104 auto dataSyncer = dataSyncManager_->GetDataSyncer(BUND_NAME_TEST, USER_ID);
105 EXPECT_EQ(USER_ID, dataSyncer->GetUserId());
106 EXPECT_EQ(BUND_NAME_TEST, dataSyncer->GetBundleName());
107
108 string bundleName2 = "com.ohos.test2";
109
110 dataSyncer = dataSyncManager_->GetDataSyncer(bundleName2, USER_ID);
111 EXPECT_EQ(USER_ID, dataSyncer->GetUserId());
112 EXPECT_EQ(bundleName2, dataSyncer->GetBundleName());
113 EXPECT_EQ(dataSyncManager_->dataSyncersMap_.Size(), 2);
114 }
115
116 /**
117 * @tc.name: IsSkipSyncOnBatteryNoOkTest
118 * @tc.desc: Verify the GetDataSyncer function
119 * @tc.type: FUNC
120 * @tc.require: I6JPKG
121 */
122 HWTEST_F(DataSyncManagerTest, IsSkipSyncOnBatteryNoOkTest, TestSize.Level1)
123 {
124 BatteryStatus::level_ = BatteryStatus::CapacityLevel::LEVEL_TOO_LOW;
125 auto ret = dataSyncManager_->IsSkipSync(BUND_NAME_TEST, USER_ID);
126 BatteryStatus::level_ = BatteryStatus::CapacityLevel::LEVEL_NORMAL;
127 EXPECT_EQ(E_SYNC_FAILED_BATTERY_TOO_LOW, ret);
128 }
129
130 /**
131 * @tc.name: IsSkipSyncOKTest
132 * @tc.desc: Verify the IsSkipSync function
133 * @tc.type: FUNC
134 * @tc.require: I6JPKG
135 */
136 HWTEST_F(DataSyncManagerTest, IsSkipSyncOKTest, TestSize.Level1)
137 {
138 auto ret = dataSyncManager_->IsSkipSync(BUND_NAME_TEST, USER_ID);
139 EXPECT_EQ(E_OK, ret);
140 }
141
142 /**
143 * @tc.name: TriggerStartSyncOKTest
144 * @tc.desc: Verify the TriggerStartSync function
145 * @tc.type: FUNC
146 * @tc.require: I6JPKG
147 */
148 HWTEST_F(DataSyncManagerTest, TriggerStartSyncNoOKTest, TestSize.Level1)
149 {
150 BatteryStatus::level_ = BatteryStatus::CapacityLevel::LEVEL_TOO_LOW;
151 auto ret = dataSyncManager_->TriggerStartSync(BUND_NAME, USER_ID,
152 false, SyncTriggerType::APP_TRIGGER);
153 BatteryStatus::level_ = BatteryStatus::CapacityLevel::LEVEL_NORMAL;
154 EXPECT_EQ(E_SYNC_FAILED_BATTERY_TOO_LOW, ret);
155 }
156
157 /**
158 * @tc.name: TriggerStartSyncOKTest
159 * @tc.desc: Verify the GetDataSyncer function
160 * @tc.type: FUNC
161 * @tc.require: I6JPKG
162 */
163 HWTEST_F(DataSyncManagerTest, TriggerStartSyncOKTest, TestSize.Level1)
164 {
165 auto ret = dataSyncManager_->TriggerStartSync(BUND_NAME, USER_ID,
166 false, SyncTriggerType::APP_TRIGGER);
167 EXPECT_EQ(E_OK, ret);
168 }
169
170 /**
171 * @tc.name: TriggerStartSyncOKTest
172 * @tc.desc: Verify the TriggerStopSync function
173 * @tc.type: FUNC
174 * @tc.require: I6JPKG
175 */
176 HWTEST_F(DataSyncManagerTest, TriggerStopSyncOKTest, TestSize.Level1)
177 {
178 auto ret = dataSyncManager_->TriggerStopSync(BUND_NAME, USER_ID, SyncTriggerType::APP_TRIGGER);
179 EXPECT_EQ(E_OK, ret);
180 }
181
182 /**
183 * @tc.name: StartDownloadFileSyncOKTest
184 * @tc.desc: Verify the StartDownloadFile function
185 * @tc.type: FUNC
186 * @tc.require: I6JPKG
187 */
188 HWTEST_F(DataSyncManagerTest, StartDownloadFileOKTest, TestSize.Level1)
189 {
190 string path = "/test";
191 auto ret = dataSyncManager_->StartDownloadFile(BUND_NAME, USER_ID, path);
192 EXPECT_TRUE(E_OK == ret || ret == E_RDB);
193 }
194
195 /**
196 * @tc.name: StopDownloadFileOKTest
197 * @tc.desc: Verify the StopDownloadFile function
198 * @tc.type: FUNC
199 * @tc.require: I6JPKG
200 */
201 HWTEST_F(DataSyncManagerTest, StopDownloadFileOKTest, TestSize.Level1)
202 {
203 string path = "/test";
204 auto ret = dataSyncManager_->StopDownloadFile(BUND_NAME, USER_ID, path);
205 EXPECT_TRUE(E_OK == ret || ret == E_RDB);
206 }
207
208 /**
209 * @tc.name: UnregisterDownloadFileCallbackOKTest
210 * @tc.desc: Verify the UnregisterDownloadFileCallback function
211 * @tc.type: FUNC
212 * @tc.require: I6JPKG
213 */
214 HWTEST_F(DataSyncManagerTest, UnregisterDownloadFileCallbackOKTest, TestSize.Level1)
215 {
216 auto ret = dataSyncManager_->UnregisterDownloadFileCallback(BUND_NAME, USER_ID);
217 EXPECT_EQ(E_OK, ret);
218 }
219
220 /**
221 * @tc.name: RegisterDownloadFileCallbackOKTest
222 * @tc.desc: Verify the RegisterDownloadFileCallback function
223 * @tc.type: FUNC
224 * @tc.require: I6JPKG
225 */
226 HWTEST_F(DataSyncManagerTest, RegisterDownloadFileCallbackOKTest, TestSize.Level1)
227 {
228 auto ret = dataSyncManager_->RegisterDownloadFileCallback(BUND_NAME, USER_ID, nullptr);
229 EXPECT_EQ(E_OK, ret);
230 }
231 } // namespace OHOS::FileManagement::CloudSync::Test