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: StartTest003
78 * @tc.desc: Verify the Start function.
79 * @tc.type: FUNC
80 * @tc.require: I6H5MH
81 */
82 HWTEST_F(CloudDiskRdbTransactionTest, StartTest003, TestSize.Level1)
83 {
84 GTEST_LOG_(INFO) << "Start Start";
85 auto rdb = std::make_shared<RdbStoreMock>();
86 auto transaction = make_shared<TransactionOperations>(rdb);
87 transaction->transaction_ = std::make_shared<transactionMock>();
88 EXPECT_CALL(*rdb, CreateTransaction(_))
89 .WillRepeatedly(Return(make_pair(NativeRdb::E_OK, transaction->transaction_)));
90
91 auto ret = transaction->Start();
92 EXPECT_EQ(ret.first, E_OK);
93 GTEST_LOG_(INFO) << "Start End";
94 }
95
96 /**
97 * @tc.name: FinishTest001
98 * @tc.desc: Verify the Finish function.
99 * @tc.type: FUNC
100 * @tc.require: I6H5MH
101 */
102 HWTEST_F(CloudDiskRdbTransactionTest, FinishTest001, TestSize.Level1)
103 {
104 GTEST_LOG_(INFO) << "Finish Start";
105 auto rdb = nullptr;
106 auto transaction = make_shared<TransactionOperations>(rdb);
107 transaction->Finish();
108 GTEST_LOG_(INFO) << "Finish End";
109 }
110
111 /**
112 * @tc.name: FinishTest002
113 * @tc.desc: Verify the Finish function.
114 * @tc.type: FUNC
115 * @tc.require: I6H5MH
116 */
117 HWTEST_F(CloudDiskRdbTransactionTest, FinishTest002, TestSize.Level1)
118 {
119 GTEST_LOG_(INFO) << "Finish Start";
120 auto rdb = std::make_shared<RdbStoreMock>();
121 auto transaction = make_shared<TransactionOperations>(rdb);
122 transaction->Finish();
123 GTEST_LOG_(INFO) << "Finish End";
124 }
125
126 /**
127 * @tc.name: FinishTest003
128 * @tc.desc: Verify the Finish function.
129 * @tc.type: FUNC
130 * @tc.require: I6H5MH
131 */
132 HWTEST_F(CloudDiskRdbTransactionTest, FinishTest003, TestSize.Level1)
133 {
134 GTEST_LOG_(INFO) << "Finish Start";
135 auto rdb = std::make_shared<RdbStoreMock>();
136 auto transaction = make_shared<TransactionOperations>(rdb);
137 transaction->isStart = true;
138 transaction->transaction_ = std::make_shared<transactionMock>();
139
140 transaction->Finish();
141 EXPECT_EQ(transaction->isStart, false);
142 GTEST_LOG_(INFO) << "Finish End";
143 }
144
145 /**
146 * @tc.name: FinishTest004
147 * @tc.desc: Verify the Finish function.
148 * @tc.type: FUNC
149 * @tc.require: I6H5MH
150 */
151 HWTEST_F(CloudDiskRdbTransactionTest, FinishTest004, TestSize.Level1)
152 {
153 GTEST_LOG_(INFO) << "Finish Start";
154 auto transaction = make_shared<TransactionOperations>(nullptr);
155 transaction->isStart = true;
156 transaction->transaction_ = nullptr;
157
158 transaction->Finish();
159 EXPECT_EQ(transaction->isFinish, false);
160 GTEST_LOG_(INFO) << "Finish End";
161 }
162
163 /**
164 * @tc.name: BeginTransactionTest001
165 * @tc.desc: Verify the BeginTransaction function.
166 * @tc.type: FUNC
167 * @tc.require: I6H5MH
168 */
169 HWTEST_F(CloudDiskRdbTransactionTest, BeginTransactionTest001, TestSize.Level1)
170 {
171 GTEST_LOG_(INFO) << "BeginTransaction Start";
172 auto rdb = nullptr;
173 auto transaction = make_shared<TransactionOperations>(rdb);
174 int32_t ret = transaction->BeginTransaction(NativeRdb::Transaction::EXCLUSIVE);
175 EXPECT_EQ(ret, E_HAS_DB_ERROR);
176 GTEST_LOG_(INFO) << "BeginTransaction End";
177 }
178
179 /**
180 * @tc.name: BeginTransactionTest003
181 * @tc.desc: Verify the BeginTransaction function.
182 * @tc.type: FUNC
183 * @tc.require: I6H5MH
184 */
185 HWTEST_F(CloudDiskRdbTransactionTest, BeginTransactionTest003, TestSize.Level1)
186 {
187 GTEST_LOG_(INFO) << "BeginTransaction Start";
188 auto rdb = std::make_shared<RdbStoreMock>();
189 auto transaction = make_shared<TransactionOperations>(rdb);
190 EXPECT_CALL(*rdb, CreateTransaction(_)).WillRepeatedly(Return(make_pair(NativeRdb::E_SQLITE_CONSTRAINT, nullptr)));
191
192 int32_t ret = transaction->BeginTransaction(NativeRdb::Transaction::EXCLUSIVE);
193 EXPECT_EQ(ret, E_SQLITE_CONSTRAINT);
194 GTEST_LOG_(INFO) << "BeginTransaction End";
195 }
196
197 /**
198 * @tc.name: BeginTransactionTest004
199 * @tc.desc: Verify the BeginTransaction function.
200 * @tc.type: FUNC
201 * @tc.require: I6H5MH
202 */
203 HWTEST_F(CloudDiskRdbTransactionTest, BeginTransactionTest004, TestSize.Level1)
204 {
205 GTEST_LOG_(INFO) << "BeginTransaction Start";
206 auto rdb = std::make_shared<RdbStoreMock>();
207 auto transaction = make_shared<TransactionOperations>(rdb);
208 transaction->transaction_ = std::make_shared<transactionMock>();
209 EXPECT_CALL(*rdb, CreateTransaction(_))
210 .WillRepeatedly(Return(make_pair(NativeRdb::E_OK, transaction->transaction_)));
211
212 int32_t ret = transaction->BeginTransaction(NativeRdb::Transaction::EXCLUSIVE);
213 EXPECT_EQ(ret, NativeRdb::E_OK);
214 GTEST_LOG_(INFO) << "BeginTransaction End";
215 }
216
217 /**
218 * @tc.name: TransactionCommitTest001
219 * @tc.desc: Verify the TransactionCommit function.
220 * @tc.type: FUNC
221 * @tc.require: I6H5MH
222 */
223 HWTEST_F(CloudDiskRdbTransactionTest, TransactionCommitTest001, TestSize.Level1)
224 {
225 GTEST_LOG_(INFO) << "TransactionCommit Start";
226 auto rdb = nullptr;
227 auto transaction = make_shared<TransactionOperations>(rdb);
228 int32_t ret = transaction->TransactionCommit();
229 EXPECT_EQ(ret, E_HAS_DB_ERROR);
230 GTEST_LOG_(INFO) << "TransactionCommit End";
231 }
232
233 /**
234 * @tc.name: TransactionCommitTest002
235 * @tc.desc: Verify the TransactionCommit function.
236 * @tc.type: FUNC
237 * @tc.require: I6H5MH
238 */
239 HWTEST_F(CloudDiskRdbTransactionTest, TransactionCommitTest002, TestSize.Level1)
240 {
241 GTEST_LOG_(INFO) << "TransactionCommit Start";
242 auto rdb = std::make_shared<RdbStoreMock>();
243 auto transaction = make_shared<TransactionOperations>(rdb);
244 int32_t ret = transaction->TransactionCommit();
245 EXPECT_EQ(ret, E_HAS_DB_ERROR);
246 GTEST_LOG_(INFO) << "TransactionCommit End";
247 }
248
249 /**
250 * @tc.name: TransactionCommitTest003
251 * @tc.desc: Verify the TransactionCommit function.
252 * @tc.type: FUNC
253 * @tc.require: I6H5MH
254 */
255 HWTEST_F(CloudDiskRdbTransactionTest, TransactionCommitTest003, TestSize.Level1)
256 {
257 GTEST_LOG_(INFO) << "TransactionCommit Start";
258 auto rdb = std::make_shared<RdbStoreMock>();
259 auto transaction = make_shared<TransactionOperations>(rdb);
260 auto tr = std::make_shared<transactionMock>();
261 transaction->transaction_ = tr;
262 EXPECT_CALL(*tr, Commit()).WillRepeatedly(Return(NativeRdb::E_BASE));
263
264 int32_t ret = transaction->TransactionCommit();
265 EXPECT_EQ(ret, E_HAS_DB_ERROR);
266 GTEST_LOG_(INFO) << "TransactionCommit End";
267 }
268
269 /**
270 * @tc.name: TransactionRollbackTest001
271 * @tc.desc: Verify the TransactionRollback function.
272 * @tc.type: FUNC
273 * @tc.require: I6H5MH
274 */
275 HWTEST_F(CloudDiskRdbTransactionTest, TransactionRollbackTest001, TestSize.Level1)
276 {
277 GTEST_LOG_(INFO) << "TransactionRollback Start";
278 auto rdb = nullptr;
279 auto transaction = make_shared<TransactionOperations>(rdb);
280 int32_t ret = transaction->TransactionRollback();
281 EXPECT_EQ(ret, E_HAS_DB_ERROR);
282 GTEST_LOG_(INFO) << "TransactionRollback End";
283 }
284
285 /**
286 * @tc.name: TransactionRollbackTest002
287 * @tc.desc: Verify the TransactionRollback function.
288 * @tc.type: FUNC
289 * @tc.require: I6H5MH
290 */
291 HWTEST_F(CloudDiskRdbTransactionTest, TransactionRollbackTest002, TestSize.Level1)
292 {
293 GTEST_LOG_(INFO) << "TransactionRollback Start";
294 auto rdb = std::make_shared<RdbStoreMock>();
295 auto transaction = make_shared<TransactionOperations>(rdb);
296 int32_t ret = transaction->TransactionRollback();
297 EXPECT_EQ(ret, E_HAS_DB_ERROR);
298 GTEST_LOG_(INFO) << "TransactionRollback End";
299 }
300 } // namespace Test
301 } // namespace FileManagement::CloudSync
302 } // namespace OHOS