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 #define MLOG_TAG "FileExtUnitTest"
16 
17 #include "ringtone_rdbstore_test.h"
18 
19 #include "ability_context_impl.h"
20 #include "rdb_store.h"
21 #include "rdb_utils.h"
22 #include "ringtone_errno.h"
23 #define private public
24 #include "ringtone_rdbstore.h"
25 #undef private
26 
27 using namespace std;
28 using namespace OHOS;
29 using namespace testing::ext;
30 
31 namespace OHOS {
32 namespace Media {
33 shared_ptr<RingtoneUnistore> g_uniStore = nullptr;
34 const std::string CREATE_RINGTONE_TABLE = "CREATE TABLE IF NOT EXISTS " + RINGTONE_TABLE + "(" +
35     RINGTONE_COLUMN_TONE_ID                       + " INTEGER  PRIMARY KEY AUTOINCREMENT, " +
36     RINGTONE_COLUMN_DATA                          + " TEXT              , " +
37     RINGTONE_COLUMN_SIZE                          + " BIGINT   DEFAULT 0, " + ")";
38 
SetUpTestCase()39 void RingtoneRdbStorelUnitTest::SetUpTestCase()
40 {
41 }
42 
TearDownTestCase()43 void RingtoneRdbStorelUnitTest::TearDownTestCase() {}
44 
45 // SetUp:Execute before each test case
SetUp()46 void RingtoneRdbStorelUnitTest::SetUp()
47 {
48     auto stageContext = std::make_shared<AbilityRuntime::ContextImpl>();
49     auto abilityContextImpl = std::make_shared<OHOS::AbilityRuntime::AbilityContextImpl>();
50     abilityContextImpl->SetStageContext(stageContext);
51     g_uniStore = RingtoneRdbStore::GetInstance(abilityContextImpl);
52     int32_t ret = g_uniStore->Init();
53     EXPECT_EQ(ret, E_OK);
54 }
55 
TearDown(void)56 void RingtoneRdbStorelUnitTest::TearDown(void) {}
57 
58 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Insert_test_001, TestSize.Level0)
59 {
60     if (g_uniStore == nullptr) {
61         exit(1);
62     }
63     Uri uri(RINGTONE_PATH_URI);
64     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
65     NativeRdb::ValuesBucket values;
66     const string name = "test name";
67     values.PutString(RINGTONE_COLUMN_DISPLAY_NAME, name);
68     const string data = "rdbStore_Insert_test_001";
69     values.PutString(RINGTONE_COLUMN_DATA, data);
70     const string title = "insert test";
71     values.PutString(RINGTONE_COLUMN_TITLE, title);
72     cmd.SetValueBucket(values);
73     g_uniStore->Init();
74     int64_t rowId = E_HAS_DB_ERROR;
75     int32_t ret = g_uniStore->Insert(cmd, rowId);
76     EXPECT_EQ(ret, E_OK);
77 }
78 
79 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Insert_test_002, TestSize.Level0)
80 {
81     if (g_uniStore == nullptr) {
82         exit(1);
83     }
84     Uri uri(RINGTONE_PATH_URI);
85     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
86     NativeRdb::ValuesBucket values;
87     const string name = "rdbStore_Insert_test_002";
88     values.PutString(RINGTONE_COLUMN_DISPLAY_NAME, name);
89     const string displayname = "rdbStore_Insert_test_002/test";
90     values.PutString(RINGTONE_COLUMN_DISPLAY_NAME, displayname);
91     cmd.SetValueBucket(values);
92     int64_t rowId = E_HAS_DB_ERROR;
93     int32_t ret = g_uniStore->Insert(cmd, rowId);
94     EXPECT_EQ(ret, E_OK);
95 }
96 
97 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Insert_test_003, TestSize.Level0)
98 {
99     if (g_uniStore == nullptr) {
100         exit(1);
101     }
102     Uri uri(RINGTONE_PATH_URI);
103     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
104     int64_t rowId = E_HAS_DB_ERROR;
105     int32_t ret = g_uniStore->Insert(cmd, rowId);
106     EXPECT_EQ(ret, E_HAS_DB_ERROR);
107 }
108 
109 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Insert_test_004, TestSize.Level0)
110 {
111     if (g_uniStore == nullptr) {
112         exit(1);
113     }
114     Uri uri(RINGTONE_PATH_URI);
115     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::INSERT);
116     NativeRdb::ValuesBucket values;
117     const string name = "rdbStore_Insert_test_004";
118     values.PutString(RINGTONE_COLUMN_DISPLAY_NAME, name);
119     cmd.SetValueBucket(values);
120     g_uniStore->Stop();
121     int64_t rowId = E_HAS_DB_ERROR;
122     int32_t ret = g_uniStore->Insert(cmd, rowId);
123     EXPECT_EQ(ret, E_HAS_DB_ERROR);
124 }
125 
126 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Query_test_001, TestSize.Level0)
127 {
128     if (g_uniStore == nullptr) {
129         exit(1);
130     }
131     Uri uri(RINGTONE_PATH_URI);
132     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
133     vector<string> columns;
134     columns.push_back(RINGTONE_COLUMN_DISPLAY_NAME);
135     g_uniStore->Init();
136     auto queryResultSet = g_uniStore->Query(cmd, columns);
137     EXPECT_NE(queryResultSet, nullptr);
138 }
139 
140 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Query_test_002, TestSize.Level0)
141 {
142     if (g_uniStore == nullptr) {
143         exit(1);
144     }
145     Uri uri(RINGTONE_PATH_URI);
146     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::QUERY);
147     vector<string> columns;
148     columns.push_back(RINGTONE_COLUMN_TITLE);
149     g_uniStore->Stop();
150     auto queryResultSet = g_uniStore->Query(cmd, columns);
151     EXPECT_EQ(queryResultSet, nullptr);
152 }
153 
154 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Delete_test_001, TestSize.Level0)
155 {
156     if (g_uniStore == nullptr) {
157         exit(1);
158     }
159     Uri uri(RINGTONE_PATH_URI);
160     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
161     int32_t rowId = 1;
162 
163     DataShare::DataSharePredicates predicates;
164     NativeRdb::RdbPredicates rdbPredicate = RdbDataShareAdapter::RdbUtils::ToPredicates(predicates, RINGTONE_TABLE);
165     cmd.GetAbsRdbPredicates()->SetWhereClause(rdbPredicate.GetWhereClause());
166     cmd.GetAbsRdbPredicates()->SetWhereArgs(rdbPredicate.GetWhereArgs());
167 
168     g_uniStore->Init();
169     int32_t ret = g_uniStore->Delete(cmd, rowId);
170     EXPECT_EQ(ret, E_OK);
171 }
172 
173 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Delete_test_002, TestSize.Level0)
174 {
175     if (g_uniStore == nullptr) {
176         exit(1);
177     }
178     g_uniStore->Stop();
179     Uri uri(RINGTONE_PATH_URI);
180     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::DELETE);
181     int32_t rowId = 1;
182     int32_t ret = g_uniStore->Delete(cmd, rowId);
183     EXPECT_EQ(ret, E_HAS_DB_ERROR);
184 }
185 
186 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Update_test_001, TestSize.Level0)
187 {
188     if (g_uniStore == nullptr) {
189         exit(1);
190     }
191     Uri uri(RINGTONE_PATH_URI);
192     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
193     NativeRdb::ValuesBucket valuesBucket;
194     const string title = "rdbStore_Update_test_001";
195     valuesBucket.PutString(RINGTONE_COLUMN_TITLE, title);
196     cmd.SetValueBucket(valuesBucket);
197     g_uniStore->Init();
198     int32_t rowId = E_HAS_DB_ERROR;
199     int32_t ret = g_uniStore->Update(cmd, rowId);
200     EXPECT_EQ(ret, E_OK);
201 }
202 
203 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Update_test_002, TestSize.Level0)
204 {
205     if (g_uniStore == nullptr) {
206         exit(1);
207     }
208     Uri uri(RINGTONE_PATH_URI);
209     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
210     int32_t updatedRows = -1;
211     int32_t ret = g_uniStore->Update(cmd, updatedRows);
212     EXPECT_EQ(ret, E_HAS_DB_ERROR);
213 }
214 
215 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_Update_test_003, TestSize.Level0)
216 {
217     if (g_uniStore == nullptr) {
218         exit(1);
219     }
220     g_uniStore->Stop();
221     Uri uri(RINGTONE_PATH_URI);
222     RingtoneDataCommand cmd(uri, RINGTONE_TABLE, RingtoneOperationType::UPDATE);
223     int32_t rowId = E_HAS_DB_ERROR;
224     int32_t ret = g_uniStore->Update(cmd, rowId);
225     EXPECT_EQ(ret, E_HAS_DB_ERROR);
226 }
227 
228 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_ExecuteSql_test_001, TestSize.Level0)
229 {
230     if (g_uniStore == nullptr) {
231         exit(1);
232     }
233     const string modifySql = "UPDATE " + RINGTONE_TABLE + " SET ";
234     int32_t ret = g_uniStore->ExecuteSql(modifySql);
235     EXPECT_EQ(ret, E_HAS_DB_ERROR);
236 }
237 
238 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_ExecuteSql_test_002, TestSize.Level0)
239 {
240     if (g_uniStore == nullptr) {
241         exit(1);
242     }
243     g_uniStore->Stop();
244     const string modifySql = "UPDATE " + RINGTONE_TABLE + " SET ";
245     int32_t ret = g_uniStore->ExecuteSql(modifySql);
246     EXPECT_EQ(ret, E_HAS_DB_ERROR);
247 }
248 
249 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_QuerySql_test_001, TestSize.Level0)
250 {
251     if (g_uniStore == nullptr) {
252         exit(1);
253     }
254     g_uniStore->Init();
255     auto queryResultSet = g_uniStore->QuerySql(CREATE_RINGTONE_TABLE);
256     EXPECT_NE(queryResultSet, nullptr);
257     EXPECT_NE(g_uniStore->GetRaw(), nullptr);
258 }
259 
260 HWTEST_F(RingtoneRdbStorelUnitTest, rdbStore_QuerySql_test_002, TestSize.Level0)
261 {
262     if (g_uniStore == nullptr) {
263         exit(1);
264     }
265     g_uniStore->Stop();
266     auto queryResultSet = g_uniStore->QuerySql(CREATE_RINGTONE_TABLE);
267     EXPECT_EQ(queryResultSet, nullptr);
268 }
269 
270 HWTEST_F(RingtoneRdbStorelUnitTest, dataCallBack_OnCreate_test_001, TestSize.Level0)
271 {
272     RingtoneDataCallBack rdbDataCallBack;
273     g_uniStore->Init();
274     auto ret = rdbDataCallBack.OnCreate(*g_uniStore->GetRaw());
275     EXPECT_EQ(ret, E_OK);;
276     int32_t oldVersion = 0;
277     int32_t newVersion = 1;
278     ret = rdbDataCallBack.OnUpgrade(*g_uniStore->GetRaw(), oldVersion, newVersion);
279     EXPECT_EQ(ret, E_OK);
280 }
281 } // namespace Media
282 } // namespace OHOS
283