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 #include <gmock/gmock.h>
17 #include <gtest/gtest.h>
18
19 #include "clouddisk_rdb_transaction.h"
20 #include "clouddisk_rdbstore_mock.h"
21 #include "utils_log.h"
22
23 namespace OHOS {
24 namespace FileManagement::CloudDisk {
25 namespace Test {
26 using namespace testing::ext;
27 using namespace std;
28
29 constexpr int32_t E_HAS_DB_ERROR = -222;
30 constexpr int32_t E_OK = 0;
31
32 class CloudDiskRdbTransactionTest : public testing::Test {
33 public:
34 static void SetUpTestCase(void);
35 static void TearDownTestCase(void);
36 void SetUp();
37 void TearDown();
38 };
39
SetUpTestCase(void)40 void CloudDiskRdbTransactionTest::SetUpTestCase(void)
41 {
42 std::cout << "SetUpTestCase" << std::endl;
43 }
44
TearDownTestCase(void)45 void CloudDiskRdbTransactionTest::TearDownTestCase(void)
46 {
47 std::cout << "TearDownTestCase" << std::endl;
48 }
49
SetUp(void)50 void CloudDiskRdbTransactionTest::SetUp(void)
51 {
52 std::cout << "SetUp" << std::endl;
53 }
54
TearDown(void)55 void CloudDiskRdbTransactionTest::TearDown(void)
56 {
57 std::cout << "TearDown" << std::endl;
58 }
59
60 /**
61 * @tc.name: StartTest001
62 * @tc.desc: Verify the Start function.
63 * @tc.type: FUNC
64 * @tc.require: I6H5MH
65 */
66 HWTEST_F(CloudDiskRdbTransactionTest, StartTest001, TestSize.Level1)
67 {
68 GTEST_LOG_(INFO) << "Start Start";
69 auto rdb = nullptr;
70 auto transaction = make_shared<TransactionOperations>(rdb);
71 auto ret = transaction->Start();
72 EXPECT_EQ(ret.first, E_HAS_DB_ERROR);
73 GTEST_LOG_(INFO) << "Start End";
74 }
75
76 /**
77 * @tc.name: StartTest002
78 * @tc.desc: Verify the Start function.
79 * @tc.type: FUNC
80 * @tc.require: ICPIJI
81 */
82 HWTEST_F(CloudDiskRdbTransactionTest, StartTest002, TestSize.Level1)
83 {
84 GTEST_LOG_(INFO) << "StartTest002 Start";
85 try {
86 auto transaction = make_shared<TransactionOperations>(nullptr);
87 transaction->isFinish = true;
88 transaction->isStart = true;
89 auto ret = transaction->Start();
90 EXPECT_EQ(ret.first, E_HAS_DB_ERROR);
91 EXPECT_EQ(ret.second, nullptr);
92 } catch (...) {
93 EXPECT_TRUE(false);
94 GTEST_LOG_(INFO) << "StartTest002 failed";
95 }
96 GTEST_LOG_(INFO) << "StartTest002 End";
97 }
98
99 /**
100 * @tc.name: StartTest003
101 * @tc.desc: Verify the Start function.
102 * @tc.type: FUNC
103 * @tc.require: I6H5MH
104 */
105 HWTEST_F(CloudDiskRdbTransactionTest, StartTest003, TestSize.Level1)
106 {
107 GTEST_LOG_(INFO) << "Start Start";
108 auto rdb = std::make_shared<RdbStoreMock>();
109 auto transaction = make_shared<TransactionOperations>(rdb);
110 transaction->transaction_ = std::make_shared<transactionMock>();
111 EXPECT_CALL(*rdb, CreateTransaction(_))
112 .WillRepeatedly(Return(make_pair(NativeRdb::E_OK, transaction->transaction_)));
113
114 auto ret = transaction->Start();
115 EXPECT_EQ(ret.first, E_OK);
116 GTEST_LOG_(INFO) << "Start End";
117 }
118
119 /**
120 * @tc.name: FinishTest001
121 * @tc.desc: Verify the Finish function.
122 * @tc.type: FUNC
123 * @tc.require: I6H5MH
124 */
125 HWTEST_F(CloudDiskRdbTransactionTest, FinishTest001, TestSize.Level1)
126 {
127 GTEST_LOG_(INFO) << "Finish Start";
128 auto rdb = nullptr;
129 auto transaction = make_shared<TransactionOperations>(rdb);
130 transaction->Finish();
131 GTEST_LOG_(INFO) << "Finish End";
132 }
133
134 /**
135 * @tc.name: FinishTest002
136 * @tc.desc: Verify the Finish function.
137 * @tc.type: FUNC
138 * @tc.require: I6H5MH
139 */
140 HWTEST_F(CloudDiskRdbTransactionTest, FinishTest002, TestSize.Level1)
141 {
142 GTEST_LOG_(INFO) << "Finish Start";
143 auto rdb = std::make_shared<RdbStoreMock>();
144 auto transaction = make_shared<TransactionOperations>(rdb);
145 transaction->Finish();
146 GTEST_LOG_(INFO) << "Finish End";
147 }
148
149 /**
150 * @tc.name: FinishTest003
151 * @tc.desc: Verify the Finish function.
152 * @tc.type: FUNC
153 * @tc.require: I6H5MH
154 */
155 HWTEST_F(CloudDiskRdbTransactionTest, FinishTest003, TestSize.Level1)
156 {
157 GTEST_LOG_(INFO) << "Finish Start";
158 auto rdb = std::make_shared<RdbStoreMock>();
159 auto transaction = make_shared<TransactionOperations>(rdb);
160 transaction->isStart = true;
161 transaction->transaction_ = std::make_shared<transactionMock>();
162
163 transaction->Finish();
164 EXPECT_EQ(transaction->isStart, false);
165 GTEST_LOG_(INFO) << "Finish End";
166 }
167
168 /**
169 * @tc.name: FinishTest004
170 * @tc.desc: Verify the Finish function.
171 * @tc.type: FUNC
172 * @tc.require: I6H5MH
173 */
174 HWTEST_F(CloudDiskRdbTransactionTest, FinishTest004, TestSize.Level1)
175 {
176 GTEST_LOG_(INFO) << "Finish Start";
177 auto transaction = make_shared<TransactionOperations>(nullptr);
178 transaction->isStart = true;
179 transaction->transaction_ = nullptr;
180
181 transaction->Finish();
182 EXPECT_EQ(transaction->isFinish, false);
183 GTEST_LOG_(INFO) << "Finish End";
184 }
185
186 /**
187 * @tc.name: BeginTransactionTest001
188 * @tc.desc: Verify the BeginTransaction function.
189 * @tc.type: FUNC
190 * @tc.require: I6H5MH
191 */
192 HWTEST_F(CloudDiskRdbTransactionTest, BeginTransactionTest001, TestSize.Level1)
193 {
194 GTEST_LOG_(INFO) << "BeginTransaction Start";
195 auto rdb = nullptr;
196 auto transaction = make_shared<TransactionOperations>(rdb);
197 int32_t ret = transaction->BeginTransaction(NativeRdb::Transaction::EXCLUSIVE);
198 EXPECT_EQ(ret, E_HAS_DB_ERROR);
199 GTEST_LOG_(INFO) << "BeginTransaction End";
200 }
201
202 /**
203 * @tc.name: BeginTransactionTest002
204 * @tc.desc: Verify the BeginTransaction function.
205 * @tc.type: FUNC
206 * @tc.require: ICPIJI
207 */
208 HWTEST_F(CloudDiskRdbTransactionTest, BeginTransactionTest002, TestSize.Level1)
209 {
210 GTEST_LOG_(INFO) << "BeginTransactionTest002 Start";
211 try {
212 auto rdb = std::make_shared<RdbStoreMock>();
213 auto transaction = make_shared<TransactionOperations>(rdb);
214 EXPECT_CALL(*rdb, CreateTransaction(_)).WillRepeatedly(Return(make_pair(NativeRdb::E_SQLITE_LOCKED, nullptr)));
215
216 int32_t ret = transaction->BeginTransaction(NativeRdb::Transaction::EXCLUSIVE);
217 EXPECT_EQ(ret, E_HAS_DB_ERROR);
218 } catch (...) {
219 EXPECT_TRUE(false);
220 GTEST_LOG_(INFO) << "BeginTransactionTest002 failed";
221 }
222 GTEST_LOG_(INFO) << "BeginTransactionTest002 End";
223 }
224
225 /**
226 * @tc.name: BeginTransactionTest003
227 * @tc.desc: Verify the BeginTransaction function.
228 * @tc.type: FUNC
229 * @tc.require: I6H5MH
230 */
231 HWTEST_F(CloudDiskRdbTransactionTest, BeginTransactionTest003, TestSize.Level1)
232 {
233 GTEST_LOG_(INFO) << "BeginTransaction Start";
234 auto rdb = std::make_shared<RdbStoreMock>();
235 auto transaction = make_shared<TransactionOperations>(rdb);
236 EXPECT_CALL(*rdb, CreateTransaction(_)).WillRepeatedly(Return(make_pair(NativeRdb::E_SQLITE_CONSTRAINT, nullptr)));
237
238 int32_t ret = transaction->BeginTransaction(NativeRdb::Transaction::EXCLUSIVE);
239 EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
240 GTEST_LOG_(INFO) << "BeginTransaction End";
241 }
242
243 /**
244 * @tc.name: BeginTransactionTest004
245 * @tc.desc: Verify the BeginTransaction function.
246 * @tc.type: FUNC
247 * @tc.require: I6H5MH
248 */
249 HWTEST_F(CloudDiskRdbTransactionTest, BeginTransactionTest004, TestSize.Level1)
250 {
251 GTEST_LOG_(INFO) << "BeginTransaction Start";
252 auto rdb = std::make_shared<RdbStoreMock>();
253 auto transaction = make_shared<TransactionOperations>(rdb);
254 transaction->transaction_ = std::make_shared<transactionMock>();
255 EXPECT_CALL(*rdb, CreateTransaction(_))
256 .WillRepeatedly(Return(make_pair(NativeRdb::E_OK, transaction->transaction_)));
257
258 int32_t ret = transaction->BeginTransaction(NativeRdb::Transaction::EXCLUSIVE);
259 EXPECT_EQ(ret, NativeRdb::E_OK);
260 GTEST_LOG_(INFO) << "BeginTransaction End";
261 }
262
263 /**
264 * @tc.name: TransactionCommitTest001
265 * @tc.desc: Verify the TransactionCommit function.
266 * @tc.type: FUNC
267 * @tc.require: I6H5MH
268 */
269 HWTEST_F(CloudDiskRdbTransactionTest, TransactionCommitTest001, TestSize.Level1)
270 {
271 GTEST_LOG_(INFO) << "TransactionCommit Start";
272 auto rdb = nullptr;
273 auto transaction = make_shared<TransactionOperations>(rdb);
274 int32_t ret = transaction->TransactionCommit();
275 EXPECT_EQ(ret, E_HAS_DB_ERROR);
276 GTEST_LOG_(INFO) << "TransactionCommit End";
277 }
278
279 /**
280 * @tc.name: TransactionCommitTest002
281 * @tc.desc: Verify the TransactionCommit function.
282 * @tc.type: FUNC
283 * @tc.require: I6H5MH
284 */
285 HWTEST_F(CloudDiskRdbTransactionTest, TransactionCommitTest002, TestSize.Level1)
286 {
287 GTEST_LOG_(INFO) << "TransactionCommit Start";
288 auto rdb = std::make_shared<RdbStoreMock>();
289 auto transaction = make_shared<TransactionOperations>(rdb);
290 int32_t ret = transaction->TransactionCommit();
291 EXPECT_EQ(ret, E_HAS_DB_ERROR);
292 GTEST_LOG_(INFO) << "TransactionCommit End";
293 }
294
295 /**
296 * @tc.name: TransactionCommitTest003
297 * @tc.desc: Verify the TransactionCommit function.
298 * @tc.type: FUNC
299 * @tc.require: I6H5MH
300 */
301 HWTEST_F(CloudDiskRdbTransactionTest, TransactionCommitTest003, TestSize.Level1)
302 {
303 GTEST_LOG_(INFO) << "TransactionCommit Start";
304 auto rdb = std::make_shared<RdbStoreMock>();
305 auto transaction = make_shared<TransactionOperations>(rdb);
306 auto tr = std::make_shared<transactionMock>();
307 transaction->transaction_ = tr;
308 EXPECT_CALL(*tr, Commit()).WillRepeatedly(Return(NativeRdb::E_BASE));
309
310 int32_t ret = transaction->TransactionCommit();
311 EXPECT_EQ(ret, E_HAS_DB_ERROR);
312 GTEST_LOG_(INFO) << "TransactionCommit End";
313 }
314
315 /**
316 * @tc.name: TransactionRollbackTest001
317 * @tc.desc: Verify the TransactionRollback function.
318 * @tc.type: FUNC
319 * @tc.require: I6H5MH
320 */
321 HWTEST_F(CloudDiskRdbTransactionTest, TransactionRollbackTest001, TestSize.Level1)
322 {
323 GTEST_LOG_(INFO) << "TransactionRollback Start";
324 auto rdb = nullptr;
325 auto transaction = make_shared<TransactionOperations>(rdb);
326 int32_t ret = transaction->TransactionRollback();
327 EXPECT_EQ(ret, E_HAS_DB_ERROR);
328 GTEST_LOG_(INFO) << "TransactionRollback End";
329 }
330
331 /**
332 * @tc.name: TransactionRollbackTest002
333 * @tc.desc: Verify the TransactionRollback function.
334 * @tc.type: FUNC
335 * @tc.require: I6H5MH
336 */
337 HWTEST_F(CloudDiskRdbTransactionTest, TransactionRollbackTest002, TestSize.Level1)
338 {
339 GTEST_LOG_(INFO) << "TransactionRollback Start";
340 auto rdb = std::make_shared<RdbStoreMock>();
341 auto transaction = make_shared<TransactionOperations>(rdb);
342 int32_t ret = transaction->TransactionRollback();
343 EXPECT_EQ(ret, E_HAS_DB_ERROR);
344 GTEST_LOG_(INFO) << "TransactionRollback End";
345 }
346 } // namespace Test
347 } // namespace FileManagement::CloudSync
348 } // namespace OHOS